forked from OctaForge/OctaCore
replace a bunch of clamp/min/max with std
This commit is contained in:
parent
a2081e6672
commit
6ea2cdb306
|
@ -1,5 +1,7 @@
|
||||||
#include "aa.hh"
|
#include "aa.hh"
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <shared/glemu.hh>
|
#include <shared/glemu.hh>
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
|
|
||||||
|
@ -84,7 +86,7 @@ VAR(debugtqaa, 0, 0, 2);
|
||||||
|
|
||||||
static void viewtqaa()
|
static void viewtqaa()
|
||||||
{
|
{
|
||||||
int w = min(hudw, hudh)*1.0f, h = (w*hudh)/hudw, tw = gw, th = gh;
|
int w = std::min(hudw, hudh)*1.0f, h = (w*hudh)/hudw, tw = gw, th = gh;
|
||||||
SETSHADER(hudrect);
|
SETSHADER(hudrect);
|
||||||
gle::colorf(1, 1, 1);
|
gle::colorf(1, 1, 1);
|
||||||
switch(debugtqaa)
|
switch(debugtqaa)
|
||||||
|
@ -330,7 +332,7 @@ static inline vec2 areaortho(float p1x, float p1y, float p2x, float p2y, float l
|
||||||
static inline void smootharea(float d, vec2 &a1, vec2 &a2)
|
static inline void smootharea(float d, vec2 &a1, vec2 &a2)
|
||||||
{
|
{
|
||||||
vec2 b1(sqrtf(a1.x*2)*0.5f, sqrtf(a1.y*2)*0.5f), b2(sqrtf(a2.x*2)*0.5f, sqrtf(a2.y*2)*0.5f);
|
vec2 b1(sqrtf(a1.x*2)*0.5f, sqrtf(a1.y*2)*0.5f), b2(sqrtf(a2.x*2)*0.5f, sqrtf(a2.y*2)*0.5f);
|
||||||
float p = clamp(d / 32.0f, 0.0f, 1.0f);
|
float p = std::clamp(d / 32.0f, 0.0f, 1.0f);
|
||||||
a1.lerp(b1, a1, p);
|
a1.lerp(b1, a1, p);
|
||||||
a2.lerp(b2, a2, p);
|
a2.lerp(b2, a2, p);
|
||||||
}
|
}
|
||||||
|
@ -387,9 +389,9 @@ static float areaunderdiag(const vec2 &p1, const vec2 &p2, const vec2 &p)
|
||||||
if(!d.x)
|
if(!d.x)
|
||||||
{
|
{
|
||||||
if(!d.y) return 1;
|
if(!d.y) return 1;
|
||||||
return clamp(d.y > 0 ? 1 - dp/d.y : dp/d.y, 0.0f, 1.0f);
|
return std::clamp(d.y > 0 ? 1 - dp/d.y : dp/d.y, 0.0f, 1.0f);
|
||||||
}
|
}
|
||||||
if(!d.y) return clamp(d.x > 0 ? 1 - dp/d.x : dp/d.x, 0.0f, 1.0f);
|
if(!d.y) return std::clamp(d.x > 0 ? 1 - dp/d.x : dp/d.x, 0.0f, 1.0f);
|
||||||
float l = dp/d.y, r = (dp-d.x)/d.y, b = dp/d.x, t = (dp-d.y)/d.x;
|
float l = dp/d.y, r = (dp-d.x)/d.y, b = dp/d.x, t = (dp-d.y)/d.x;
|
||||||
if(0 <= dp)
|
if(0 <= dp)
|
||||||
{
|
{
|
||||||
|
@ -400,25 +402,25 @@ static float areaunderdiag(const vec2 &p1, const vec2 &p2, const vec2 &p)
|
||||||
if(d.y+d.x <= dp) return 0;
|
if(d.y+d.x <= dp) return 0;
|
||||||
return 0.5f*(1-r)*(1-t);
|
return 0.5f*(1-r)*(1-t);
|
||||||
}
|
}
|
||||||
if(d.y+d.x > dp) return min(1-b, 1-t) + 0.5f*fabs(b-t);
|
if(d.y+d.x > dp) return std::min(1-b, 1-t) + 0.5f*fabs(b-t);
|
||||||
return 0.5f*(1-b)*r;
|
return 0.5f*(1-b)*r;
|
||||||
}
|
}
|
||||||
if(d.x <= dp)
|
if(d.x <= dp)
|
||||||
{
|
{
|
||||||
if(d.y+d.x <= dp) return 0.5f*(1-l)*t;
|
if(d.y+d.x <= dp) return 0.5f*(1-l)*t;
|
||||||
return min(1-l, 1-r) + 0.5f*fabs(r-l);
|
return std::min(1-l, 1-r) + 0.5f*fabs(r-l);
|
||||||
}
|
}
|
||||||
return 1 - 0.5f*l*b;
|
return 1 - 0.5f*l*b;
|
||||||
}
|
}
|
||||||
if(d.y <= dp)
|
if(d.y <= dp)
|
||||||
{
|
{
|
||||||
if(d.x <= dp) return 0.5f*l*b;
|
if(d.x <= dp) return 0.5f*l*b;
|
||||||
if(d.y+d.x <= dp) return min(l, r) + 0.5f*fabs(r-l);
|
if(d.y+d.x <= dp) return std::min(l, r) + 0.5f*fabs(r-l);
|
||||||
return 1 - 0.5f*(1-l)*t;
|
return 1 - 0.5f*(1-l)*t;
|
||||||
}
|
}
|
||||||
if(d.x <= dp)
|
if(d.x <= dp)
|
||||||
{
|
{
|
||||||
if(d.y+d.x <= dp) return min(b, t) + 0.5f*fabs(b-t);
|
if(d.y+d.x <= dp) return std::min(b, t) + 0.5f*fabs(b-t);
|
||||||
return 1 - 0.5f*(1-b)*r;
|
return 1 - 0.5f*(1-b)*r;
|
||||||
}
|
}
|
||||||
if(d.y+d.x <= dp) return 1 - 0.5f*(1-t)*(1-r);
|
if(d.y+d.x <= dp) return 1 - 0.5f*(1-t)*(1-r);
|
||||||
|
@ -570,7 +572,7 @@ static void setupsmaa(int w, int h)
|
||||||
|
|
||||||
static void viewsmaa()
|
static void viewsmaa()
|
||||||
{
|
{
|
||||||
int w = min(hudw, hudh)*1.0f, h = (w*hudh)/hudw, tw = gw, th = gh;
|
int w = std::min(hudw, hudh)*1.0f, h = (w*hudh)/hudw, tw = gw, th = gh;
|
||||||
SETSHADER(hudrect);
|
SETSHADER(hudrect);
|
||||||
gle::colorf(1, 1, 1);
|
gle::colorf(1, 1, 1);
|
||||||
switch(debugsmaa)
|
switch(debugsmaa)
|
||||||
|
|
|
@ -42,8 +42,8 @@ struct animmodel : model
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
fr1 = min(fr1, info.range-1)+info.frame;
|
fr1 = std::min(fr1, info.range-1)+info.frame;
|
||||||
fr2 = min(fr1+1, info.frame+info.range-1);
|
fr2 = std::min(fr1+1, info.frame+info.range-1);
|
||||||
}
|
}
|
||||||
if(info.anim&ANIM_REVERSE)
|
if(info.anim&ANIM_REVERSE)
|
||||||
{
|
{
|
||||||
|
@ -547,7 +547,7 @@ struct animmodel : model
|
||||||
virtual int totalframes() const { return 1; }
|
virtual int totalframes() const { return 1; }
|
||||||
bool hasframe(int i) const { return i>=0 && i<totalframes(); }
|
bool hasframe(int i) const { return i>=0 && i<totalframes(); }
|
||||||
bool hasframes(int i, int n) const { return i>=0 && i+n<=totalframes(); }
|
bool hasframes(int i, int n) const { return i>=0 && i+n<=totalframes(); }
|
||||||
int clipframes(int i, int n) const { return min(n, totalframes() - i); }
|
int clipframes(int i, int n) const { return std::min(n, totalframes() - i); }
|
||||||
|
|
||||||
virtual void cleanup() {}
|
virtual void cleanup() {}
|
||||||
virtual void preload(part *p) {}
|
virtual void preload(part *p) {}
|
||||||
|
@ -837,7 +837,7 @@ struct animmodel : model
|
||||||
if(d && interp>=0)
|
if(d && interp>=0)
|
||||||
{
|
{
|
||||||
animinterpinfo &ai = d->animinterp[interp];
|
animinterpinfo &ai = d->animinterp[interp];
|
||||||
if((info.anim&(ANIM_LOOP|ANIM_CLAMP))==ANIM_CLAMP) aitime = min(aitime, int(info.range*info.speed*0.5e-3f));
|
if((info.anim&(ANIM_LOOP|ANIM_CLAMP))==ANIM_CLAMP) aitime = std::min(aitime, int(info.range*info.speed*0.5e-3f));
|
||||||
void *ak = meshes->animkey();
|
void *ak = meshes->animkey();
|
||||||
if(d->ragdoll && d->ragdoll->millis != lastmillis)
|
if(d->ragdoll && d->ragdoll->millis != lastmillis)
|
||||||
{
|
{
|
||||||
|
@ -894,7 +894,7 @@ struct animmodel : model
|
||||||
vec oaxis, oforward, oo, oray;
|
vec oaxis, oforward, oo, oray;
|
||||||
matrixstack[matrixpos].transposedtransformnormal(axis, oaxis);
|
matrixstack[matrixpos].transposedtransformnormal(axis, oaxis);
|
||||||
float pitchamount = pitchscale*pitch + pitchoffset;
|
float pitchamount = pitchscale*pitch + pitchoffset;
|
||||||
if((pitchmin || pitchmax) && pitchmin <= pitchmax) pitchamount = clamp(pitchamount, pitchmin, pitchmax);
|
if((pitchmin || pitchmax) && pitchmin <= pitchmax) pitchamount = std::clamp(pitchamount, pitchmin, pitchmax);
|
||||||
if(as->cur.anim&ANIM_NOPITCH || (as->interp < 1 && as->prev.anim&ANIM_NOPITCH))
|
if(as->cur.anim&ANIM_NOPITCH || (as->interp < 1 && as->prev.anim&ANIM_NOPITCH))
|
||||||
pitchamount *= (as->cur.anim&ANIM_NOPITCH ? 0 : as->interp) + (as->interp < 1 && as->prev.anim&ANIM_NOPITCH ? 0 : 1-as->interp);
|
pitchamount *= (as->cur.anim&ANIM_NOPITCH ? 0 : as->interp) + (as->interp < 1 && as->prev.anim&ANIM_NOPITCH ? 0 : 1-as->interp);
|
||||||
if(pitchamount)
|
if(pitchamount)
|
||||||
|
@ -980,7 +980,7 @@ struct animmodel : model
|
||||||
vec oaxis, oforward;
|
vec oaxis, oforward;
|
||||||
matrixstack[matrixpos].transposedtransformnormal(axis, oaxis);
|
matrixstack[matrixpos].transposedtransformnormal(axis, oaxis);
|
||||||
float pitchamount = pitchscale*pitch + pitchoffset;
|
float pitchamount = pitchscale*pitch + pitchoffset;
|
||||||
if(pitchmin || pitchmax) pitchamount = clamp(pitchamount, pitchmin, pitchmax);
|
if(pitchmin || pitchmax) pitchamount = std::clamp(pitchamount, pitchmin, pitchmax);
|
||||||
if(as->cur.anim&ANIM_NOPITCH || (as->interp < 1 && as->prev.anim&ANIM_NOPITCH))
|
if(as->cur.anim&ANIM_NOPITCH || (as->interp < 1 && as->prev.anim&ANIM_NOPITCH))
|
||||||
pitchamount *= (as->cur.anim&ANIM_NOPITCH ? 0 : as->interp) + (as->interp < 1 && as->prev.anim&ANIM_NOPITCH ? 0 : 1-as->interp);
|
pitchamount *= (as->cur.anim&ANIM_NOPITCH ? 0 : as->interp) + (as->interp < 1 && as->prev.anim&ANIM_NOPITCH ? 0 : 1-as->interp);
|
||||||
if(pitchamount)
|
if(pitchamount)
|
||||||
|
@ -1786,7 +1786,7 @@ template<class MDL, class MESH> struct modelcommands
|
||||||
|
|
||||||
static void setgloss(char *meshname, int *gloss)
|
static void setgloss(char *meshname, int *gloss)
|
||||||
{
|
{
|
||||||
loopskins(meshname, s, s.gloss = clamp(*gloss, 0, 2));
|
loopskins(meshname, s, s.gloss = std::clamp(*gloss, 0, 2));
|
||||||
}
|
}
|
||||||
|
|
||||||
static void setglow(char *meshname, float *percent, float *delta, float *pulse)
|
static void setglow(char *meshname, float *percent, float *delta, float *pulse)
|
||||||
|
@ -1798,7 +1798,7 @@ template<class MDL, class MESH> struct modelcommands
|
||||||
|
|
||||||
static void setalphatest(char *meshname, float *cutoff)
|
static void setalphatest(char *meshname, float *cutoff)
|
||||||
{
|
{
|
||||||
loopskins(meshname, s, s.alphatest = max(0.0f, min(1.0f, *cutoff)));
|
loopskins(meshname, s, s.alphatest = std::max(0.0f, std::min(1.0f, *cutoff)));
|
||||||
}
|
}
|
||||||
|
|
||||||
static void setcullface(char *meshname, int *cullface)
|
static void setcullface(char *meshname, int *cullface)
|
||||||
|
|
|
@ -1,3 +1,5 @@
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include "ents.hh"
|
#include "ents.hh"
|
||||||
#include "physics.hh"
|
#include "physics.hh"
|
||||||
#include "rendermodel.hh" // loadmapmodel
|
#include "rendermodel.hh" // loadmapmodel
|
||||||
|
@ -36,8 +38,8 @@ bool BIH::triintersect(const mesh &m, int tidx, const vec &mo, const vec &mray,
|
||||||
{
|
{
|
||||||
vec2 at = m.gettc(t.vert[0]), bt = m.gettc(t.vert[1]).sub(at).mul(v*invdet), ct = m.gettc(t.vert[2]).sub(at).mul(w*invdet);
|
vec2 at = m.gettc(t.vert[0]), bt = m.gettc(t.vert[1]).sub(at).mul(v*invdet), ct = m.gettc(t.vert[2]).sub(at).mul(w*invdet);
|
||||||
at.add(bt).add(ct);
|
at.add(bt).add(ct);
|
||||||
int si = clamp(int(m.tex->xs * at.x), 0, m.tex->xs-1),
|
int si = std::clamp(int(m.tex->xs * at.x), 0, m.tex->xs-1),
|
||||||
ti = clamp(int(m.tex->ys * at.y), 0, m.tex->ys-1);
|
ti = std::clamp(int(m.tex->ys * at.y), 0, m.tex->ys-1);
|
||||||
if(!(m.tex->alphamask[ti*((m.tex->xs+7)/8) + si/8] & (1<<(si%8)))) return false;
|
if(!(m.tex->alphamask[ti*((m.tex->xs+7)/8) + si/8] & (1<<(si%8)))) return false;
|
||||||
}
|
}
|
||||||
if(!(mode&RAY_SHADOW)) hitsurface = m.xformnorm.transform(n).normalize();
|
if(!(mode&RAY_SHADOW)) hitsurface = m.xformnorm.transform(n).normalize();
|
||||||
|
@ -71,7 +73,7 @@ inline bool BIH::traverse(const mesh &m, const vec &o, const vec &ray, const vec
|
||||||
if(!curnode->isleaf(faridx))
|
if(!curnode->isleaf(faridx))
|
||||||
{
|
{
|
||||||
curnode += curnode->childindex(faridx);
|
curnode += curnode->childindex(faridx);
|
||||||
tmin = max(tmin, farsplit);
|
tmin = std::max(tmin, farsplit);
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
else if(triintersect(m, curnode->childindex(faridx), mo, mray, maxdist, dist, mode)) return true;
|
else if(triintersect(m, curnode->childindex(faridx), mo, mray, maxdist, dist, mode)) return true;
|
||||||
|
@ -85,7 +87,7 @@ inline bool BIH::traverse(const mesh &m, const vec &o, const vec &ray, const vec
|
||||||
if(!curnode->isleaf(faridx))
|
if(!curnode->isleaf(faridx))
|
||||||
{
|
{
|
||||||
curnode += curnode->childindex(faridx);
|
curnode += curnode->childindex(faridx);
|
||||||
tmin = max(tmin, farsplit);
|
tmin = std::max(tmin, farsplit);
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
else if(triintersect(m, curnode->childindex(faridx), mo, mray, maxdist, dist, mode)) return true;
|
else if(triintersect(m, curnode->childindex(faridx), mo, mray, maxdist, dist, mode)) return true;
|
||||||
|
@ -101,21 +103,21 @@ inline bool BIH::traverse(const mesh &m, const vec &o, const vec &ray, const vec
|
||||||
{
|
{
|
||||||
traversestate &save = stack[stacksize++];
|
traversestate &save = stack[stacksize++];
|
||||||
save.node = curnode + curnode->childindex(faridx);
|
save.node = curnode + curnode->childindex(faridx);
|
||||||
save.tmin = max(tmin, farsplit);
|
save.tmin = std::max(tmin, farsplit);
|
||||||
save.tmax = tmax;
|
save.tmax = tmax;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
if(traverse(m, o, ray, invray, maxdist, dist, mode, curnode + curnode->childindex(nearidx), tmin, min(tmax, nearsplit))) return true;
|
if(traverse(m, o, ray, invray, maxdist, dist, mode, curnode + curnode->childindex(nearidx), tmin, std::min(tmax, nearsplit))) return true;
|
||||||
curnode += curnode->childindex(faridx);
|
curnode += curnode->childindex(faridx);
|
||||||
tmin = max(tmin, farsplit);
|
tmin = std::max(tmin, farsplit);
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else if(triintersect(m, curnode->childindex(faridx), mo, mray, maxdist, dist, mode)) return true;
|
else if(triintersect(m, curnode->childindex(faridx), mo, mray, maxdist, dist, mode)) return true;
|
||||||
}
|
}
|
||||||
curnode += curnode->childindex(nearidx);
|
curnode += curnode->childindex(nearidx);
|
||||||
tmax = min(tmax, nearsplit);
|
tmax = std::min(tmax, nearsplit);
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
if(stacksize <= 0) return false;
|
if(stacksize <= 0) return false;
|
||||||
|
@ -139,11 +141,11 @@ inline bool BIH::traverse(const vec &o, const vec &ray, float maxdist, float &di
|
||||||
if(invray.x > 0) { tmin = t1; tmax = t2; } else { tmin = t2; tmax = t1; }
|
if(invray.x > 0) { tmin = t1; tmax = t2; } else { tmin = t2; tmax = t1; }
|
||||||
t1 = (m.bbmin.y - o.y)*invray.y;
|
t1 = (m.bbmin.y - o.y)*invray.y;
|
||||||
t2 = (m.bbmax.y - o.y)*invray.y;
|
t2 = (m.bbmax.y - o.y)*invray.y;
|
||||||
if(invray.y > 0) { tmin = max(tmin, t1); tmax = min(tmax, t2); } else { tmin = max(tmin, t2); tmax = min(tmax, t1); }
|
if(invray.y > 0) { tmin = std::max(tmin, t1); tmax = std::min(tmax, t2); } else { tmin = std::max(tmin, t2); tmax = std::min(tmax, t1); }
|
||||||
t1 = (m.bbmin.z - o.z)*invray.z;
|
t1 = (m.bbmin.z - o.z)*invray.z;
|
||||||
t2 = (m.bbmax.z - o.z)*invray.z;
|
t2 = (m.bbmax.z - o.z)*invray.z;
|
||||||
if(invray.z > 0) { tmin = max(tmin, t1); tmax = min(tmax, t2); } else { tmin = max(tmin, t2); tmax = min(tmax, t1); }
|
if(invray.z > 0) { tmin = std::max(tmin, t1); tmax = std::min(tmax, t2); } else { tmin = std::max(tmin, t2); tmax = std::min(tmax, t1); }
|
||||||
tmax = min(tmax, maxdist);
|
tmax = std::min(tmax, maxdist);
|
||||||
if(tmin < tmax && traverse(m, o, ray, invray, maxdist, dist, mode, m.nodes, tmin, tmax)) return true;
|
if(tmin < tmax && traverse(m, o, ray, invray, maxdist, dist, mode, m.nodes, tmin, tmax)) return true;
|
||||||
}
|
}
|
||||||
return false;
|
return false;
|
||||||
|
@ -168,10 +170,10 @@ void BIH::build(mesh &m, ushort *indices, int numindices, const ivec &vmin, cons
|
||||||
ivec trimin = ivec(tri.center).sub(ivec(tri.radius)),
|
ivec trimin = ivec(tri.center).sub(ivec(tri.radius)),
|
||||||
trimax = ivec(tri.center).add(ivec(tri.radius));
|
trimax = ivec(tri.center).add(ivec(tri.radius));
|
||||||
int amin = trimin[axis], amax = trimax[axis];
|
int amin = trimin[axis], amax = trimax[axis];
|
||||||
if(max(split - amin, 0) > max(amax - split, 0))
|
if(std::max(split - amin, 0) > std::max(amax - split, 0))
|
||||||
{
|
{
|
||||||
++left;
|
++left;
|
||||||
splitleft = max(splitleft, amax);
|
splitleft = std::max(splitleft, amax);
|
||||||
leftmin.min(trimin);
|
leftmin.min(trimin);
|
||||||
leftmax.max(trimax);
|
leftmax.max(trimax);
|
||||||
}
|
}
|
||||||
|
@ -179,7 +181,7 @@ void BIH::build(mesh &m, ushort *indices, int numindices, const ivec &vmin, cons
|
||||||
{
|
{
|
||||||
--right;
|
--right;
|
||||||
swap(indices[left], indices[right]);
|
swap(indices[left], indices[right]);
|
||||||
splitright = min(splitright, amin);
|
splitright = std::min(splitright, amin);
|
||||||
rightmin.min(trimin);
|
rightmin.min(trimin);
|
||||||
rightmax.max(trimax);
|
rightmax.max(trimax);
|
||||||
}
|
}
|
||||||
|
@ -202,13 +204,13 @@ void BIH::build(mesh &m, ushort *indices, int numindices, const ivec &vmin, cons
|
||||||
trimax = ivec(tri.center).add(ivec(tri.radius));
|
trimax = ivec(tri.center).add(ivec(tri.radius));
|
||||||
if(i < left)
|
if(i < left)
|
||||||
{
|
{
|
||||||
splitleft = max(splitleft, trimax[axis]);
|
splitleft = std::max(splitleft, trimax[axis]);
|
||||||
leftmin.min(trimin);
|
leftmin.min(trimin);
|
||||||
leftmax.max(trimax);
|
leftmax.max(trimax);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
splitright = min(splitright, trimin[axis]);
|
splitright = std::min(splitright, trimin[axis]);
|
||||||
rightmin.min(trimin);
|
rightmin.min(trimin);
|
||||||
rightmax.max(trimax);
|
rightmax.max(trimax);
|
||||||
}
|
}
|
||||||
|
@ -366,7 +368,7 @@ static inline float segmentdistance(const vec &d1, const vec &d2, const vec &r)
|
||||||
{
|
{
|
||||||
if(e <= 1e-4f) return r.squaredlen();
|
if(e <= 1e-4f) return r.squaredlen();
|
||||||
s = 0;
|
s = 0;
|
||||||
t = clamp(-f / e, 0.0f, 1.0f);
|
t = std::clamp(-f / e, 0.0f, 1.0f);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -374,22 +376,22 @@ static inline float segmentdistance(const vec &d1, const vec &d2, const vec &r)
|
||||||
if(e <= 1e-4f)
|
if(e <= 1e-4f)
|
||||||
{
|
{
|
||||||
t = 0;
|
t = 0;
|
||||||
s = clamp(c / a, 0.0f, 1.0f);
|
s = std::clamp(c / a, 0.0f, 1.0f);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
float b = d1.dot(d2), denom = a*e - b*b;
|
float b = d1.dot(d2), denom = a*e - b*b;
|
||||||
s = denom ? clamp((c*e - b*f) / denom, 0.0f, 1.0f) : 0.0f;
|
s = denom ? std::clamp((c*e - b*f) / denom, 0.0f, 1.0f) : 0.0f;
|
||||||
t = b*s - f;
|
t = b*s - f;
|
||||||
if(t < 0)
|
if(t < 0)
|
||||||
{
|
{
|
||||||
t = 0;
|
t = 0;
|
||||||
s = clamp(c / a, 0.0f, 1.0f);
|
s = std::clamp(c / a, 0.0f, 1.0f);
|
||||||
}
|
}
|
||||||
else if(t > e)
|
else if(t > e)
|
||||||
{
|
{
|
||||||
t = 1;
|
t = 1;
|
||||||
s = clamp((b + c) / a, 0.0f, 1.0f);
|
s = std::clamp((b + c) / a, 0.0f, 1.0f);
|
||||||
}
|
}
|
||||||
else t /= e;
|
else t /= e;
|
||||||
}
|
}
|
||||||
|
@ -413,34 +415,34 @@ static inline float trisegmentdistance(const vec &a, const vec &b, const vec &c,
|
||||||
if(ap.dot(nab) < 0) // P outside AB
|
if(ap.dot(nab) < 0) // P outside AB
|
||||||
{
|
{
|
||||||
dist = segmentdistance(ab, pq, ap);
|
dist = segmentdistance(ab, pq, ap);
|
||||||
if(bq.dot(nbc) < 0) dist = min(dist, segmentdistance(bc, pq, bp)); // Q outside BC
|
if(bq.dot(nbc) < 0) dist = std::min(dist, segmentdistance(bc, pq, bp)); // Q outside BC
|
||||||
else if(aq.dot(nca) < 0) dist = min(dist, segmentdistance(pq, ca, cp)); // Q outside CA
|
else if(aq.dot(nca) < 0) dist = std::min(dist, segmentdistance(pq, ca, cp)); // Q outside CA
|
||||||
else if(aq.dot(nab) >= 0) dist = min(dist, dq*dq/n.squaredlen()); // Q inside AB
|
else if(aq.dot(nab) >= 0) dist = std::min(dist, dq*dq/n.squaredlen()); // Q inside AB
|
||||||
else return dist;
|
else return dist;
|
||||||
}
|
}
|
||||||
else if(bp.dot(nbc) < 0) // P outside BC
|
else if(bp.dot(nbc) < 0) // P outside BC
|
||||||
{
|
{
|
||||||
dist = segmentdistance(bc, pq, bp);
|
dist = segmentdistance(bc, pq, bp);
|
||||||
if(aq.dot(nca) < 0) dist = min(dist, segmentdistance(ca, pq, cp)); // Q outside CA
|
if(aq.dot(nca) < 0) dist = std::min(dist, segmentdistance(ca, pq, cp)); // Q outside CA
|
||||||
else if(aq.dot(nab) < 0) dist = min(dist, segmentdistance(ab, pq, ap)); // Q outside AB
|
else if(aq.dot(nab) < 0) dist = std::min(dist, segmentdistance(ab, pq, ap)); // Q outside AB
|
||||||
else if(bq.dot(nbc) >= 0) dist = min(dist, dq*dq/n.squaredlen()); // Q inside BC
|
else if(bq.dot(nbc) >= 0) dist = std::min(dist, dq*dq/n.squaredlen()); // Q inside BC
|
||||||
else return dist;
|
else return dist;
|
||||||
}
|
}
|
||||||
else if(cp.dot(nca) < 0) // P outside CA
|
else if(cp.dot(nca) < 0) // P outside CA
|
||||||
{
|
{
|
||||||
dist = segmentdistance(ca, pq, cp);
|
dist = segmentdistance(ca, pq, cp);
|
||||||
if(aq.dot(nab) < 0) dist = min(dist, segmentdistance(ab, pq, ap)); // Q outside AB
|
if(aq.dot(nab) < 0) dist = std::min(dist, segmentdistance(ab, pq, ap)); // Q outside AB
|
||||||
else if(bq.dot(nbc) < 0) dist = min(dist, segmentdistance(bc, pq, bp)); // Q outside BC
|
else if(bq.dot(nbc) < 0) dist = std::min(dist, segmentdistance(bc, pq, bp)); // Q outside BC
|
||||||
else if(aq.dot(nca) >= 0) dist = min(dist, dq*dq/n.squaredlen()); // Q inside CA
|
else if(aq.dot(nca) >= 0) dist = std::min(dist, dq*dq/n.squaredlen()); // Q inside CA
|
||||||
else return dist;
|
else return dist;
|
||||||
}
|
}
|
||||||
else if(aq.dot(nab) < 0) dist = min(segmentdistance(ab, pq, ap), dp); // Q outside AB
|
else if(aq.dot(nab) < 0) dist = std::min(segmentdistance(ab, pq, ap), dp); // Q outside AB
|
||||||
else if(bq.dot(nbc) < 0) dist = min(segmentdistance(bc, pq, bp), dp); // Q outside BC
|
else if(bq.dot(nbc) < 0) dist = std::min(segmentdistance(bc, pq, bp), dp); // Q outside BC
|
||||||
else if(aq.dot(nca) < 0) dist = min(segmentdistance(ca, pq, cp), dp); // Q outside CA
|
else if(aq.dot(nca) < 0) dist = std::min(segmentdistance(ca, pq, cp), dp); // Q outside CA
|
||||||
else // both P and Q inside
|
else // both P and Q inside
|
||||||
{
|
{
|
||||||
if(dp > 0 ? dq <= 0 : dq >= 0) return 0; // P and Q on different sides of triangle
|
if(dp > 0 ? dq <= 0 : dq >= 0) return 0; // P and Q on different sides of triangle
|
||||||
dist = min(dp*dp, dq*dq)/n.squaredlen();
|
dist = std::min(dp*dp, dq*dq)/n.squaredlen();
|
||||||
return dist;
|
return dist;
|
||||||
}
|
}
|
||||||
if(dp > 0 ? dq >= 0 : dq <= 0) return dist; // both P and Q on same side of triangle
|
if(dp > 0 ? dq >= 0 : dq <= 0) return dist; // both P and Q on same side of triangle
|
||||||
|
@ -480,10 +482,10 @@ static inline bool triboxoverlap(const vec &radius, const vec &a, const vec &b,
|
||||||
if(a.w < b.w) \
|
if(a.w < b.w) \
|
||||||
{ \
|
{ \
|
||||||
if(b.w < c.w) { if(c.w < -radius.w || a.w > radius.w) return false; } \
|
if(b.w < c.w) { if(c.w < -radius.w || a.w > radius.w) return false; } \
|
||||||
else if(b.w < -radius.w || min(a.w, c.w) > radius.w) return false; \
|
else if(b.w < -radius.w || std::min(a.w, c.w) > radius.w) return false; \
|
||||||
} \
|
} \
|
||||||
else if(a.w < c.w) { if(c.w < -radius.w || b.w > radius.w) return false; } \
|
else if(a.w < c.w) { if(c.w < -radius.w || b.w > radius.w) return false; } \
|
||||||
else if(a.w < -radius.w || min(b.w, c.w) > radius.w) return false; \
|
else if(a.w < -radius.w || std::min(b.w, c.w) > radius.w) return false; \
|
||||||
}
|
}
|
||||||
|
|
||||||
TESTFACE(x);
|
TESTFACE(x);
|
||||||
|
@ -551,7 +553,7 @@ inline void BIH::tricollide<COLLIDE_OBB>(const mesh &m, int tidx, physent *d, co
|
||||||
if(d->type==ENT_PLAYER &&
|
if(d->type==ENT_PLAYER &&
|
||||||
pdist < (dir.z*n.z < 0 ?
|
pdist < (dir.z*n.z < 0 ?
|
||||||
2*radius.z*(d->zmargin/(d->aboveeye+d->eyeheight)-(dir.z < 0 ? 1/3.0f : 1/4.0f)) :
|
2*radius.z*(d->zmargin/(d->aboveeye+d->eyeheight)-(dir.z < 0 ? 1/3.0f : 1/4.0f)) :
|
||||||
(dir.x*n.x < 0 || dir.y*n.y < 0 ? -max(radius.x, radius.y) : 0)))
|
(dir.x*n.x < 0 || dir.y*n.y < 0 ? -std::max(radius.x, radius.y) : 0)))
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -1,5 +1,7 @@
|
||||||
#include "blend.hh"
|
#include "blend.hh"
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
#include <shared/igame.hh>
|
#include <shared/igame.hh>
|
||||||
|
|
||||||
|
@ -150,9 +152,9 @@ bool setblendmaporigin(BlendMapCache *cache, const ivec &o, int size)
|
||||||
BlendMapBranch *bm = blendmap.branch;
|
BlendMapBranch *bm = blendmap.branch;
|
||||||
int bmscale = worldscale-BM_SCALE, bmsize = 1<<bmscale,
|
int bmscale = worldscale-BM_SCALE, bmsize = 1<<bmscale,
|
||||||
x = o.x>>BM_SCALE, y = o.y>>BM_SCALE,
|
x = o.x>>BM_SCALE, y = o.y>>BM_SCALE,
|
||||||
x1 = max(x-1, 0), y1 = max(y-1, 0),
|
x1 = std::max(x-1, 0), y1 = std::max(y-1, 0),
|
||||||
x2 = min(((o.x + size + (1<<BM_SCALE)-1)>>BM_SCALE) + 1, bmsize),
|
x2 = std::min(((o.x + size + (1<<BM_SCALE)-1)>>BM_SCALE) + 1, bmsize),
|
||||||
y2 = min(((o.y + size + (1<<BM_SCALE)-1)>>BM_SCALE) + 1, bmsize),
|
y2 = std::min(((o.y + size + (1<<BM_SCALE)-1)>>BM_SCALE) + 1, bmsize),
|
||||||
diff = (x1^x2)|(y1^y2);
|
diff = (x1^x2)|(y1^y2);
|
||||||
if(diff < bmsize) while(!(diff&(1<<(bmscale-1))))
|
if(diff < bmsize) while(!(diff&(1<<(bmscale-1))))
|
||||||
{
|
{
|
||||||
|
@ -205,7 +207,7 @@ uchar lookupblendmap(BlendMapCache *cache, const vec &pos)
|
||||||
rx = ix-cache->origin.x, ry = iy-cache->origin.y;
|
rx = ix-cache->origin.x, ry = iy-cache->origin.y;
|
||||||
loop(vy, 2) loop(vx, 2)
|
loop(vy, 2) loop(vx, 2)
|
||||||
{
|
{
|
||||||
int cx = clamp(rx+vx, 0, (1<<cache->scale)-1), cy = clamp(ry+vy, 0, (1<<cache->scale)-1);
|
int cx = std::clamp(rx+vx, 0, (1<<cache->scale)-1), cy = std::clamp(ry+vy, 0, (1<<cache->scale)-1);
|
||||||
if(cache->node.type==BM_IMAGE)
|
if(cache->node.type==BM_IMAGE)
|
||||||
*val++ = cache->node.image->data[cy*BM_IMAGE_SIZE + cx];
|
*val++ = cache->node.image->data[cy*BM_IMAGE_SIZE + cx];
|
||||||
else *val++ = lookupblendmap(cx, cy, cache->node.branch, cache->scale);
|
else *val++ = lookupblendmap(cx, cy, cache->node.branch, cache->scale);
|
||||||
|
@ -217,7 +219,7 @@ uchar lookupblendmap(BlendMapCache *cache, const vec &pos)
|
||||||
|
|
||||||
static void fillblendmap(uchar &type, BlendMapNode &node, int size, uchar val, int x1, int y1, int x2, int y2)
|
static void fillblendmap(uchar &type, BlendMapNode &node, int size, uchar val, int x1, int y1, int x2, int y2)
|
||||||
{
|
{
|
||||||
if(max(x1, y1) <= 0 && min(x2, y2) >= size)
|
if(std::max(x1, y1) <= 0 && std::min(x2, y2) >= size)
|
||||||
{
|
{
|
||||||
node.cleanup(type);
|
node.cleanup(type);
|
||||||
type = BM_SOLID;
|
type = BM_SOLID;
|
||||||
|
@ -231,16 +233,16 @@ static void fillblendmap(uchar &type, BlendMapNode &node, int size, uchar val, i
|
||||||
if(y1 < size)
|
if(y1 < size)
|
||||||
{
|
{
|
||||||
if(x1 < size) fillblendmap(node.branch->type[0], node.branch->children[0], size, val,
|
if(x1 < size) fillblendmap(node.branch->type[0], node.branch->children[0], size, val,
|
||||||
x1, y1, min(x2, size), min(y2, size));
|
x1, y1, std::min(x2, size), std::min(y2, size));
|
||||||
if(x2 > size) fillblendmap(node.branch->type[1], node.branch->children[1], size, val,
|
if(x2 > size) fillblendmap(node.branch->type[1], node.branch->children[1], size, val,
|
||||||
max(x1-size, 0), y1, x2-size, min(y2, size));
|
std::max(x1-size, 0), y1, x2-size, std::min(y2, size));
|
||||||
}
|
}
|
||||||
if(y2 > size)
|
if(y2 > size)
|
||||||
{
|
{
|
||||||
if(x1 < size) fillblendmap(node.branch->type[2], node.branch->children[2], size, val,
|
if(x1 < size) fillblendmap(node.branch->type[2], node.branch->children[2], size, val,
|
||||||
x1, max(y1-size, 0), min(x2, size), y2-size);
|
x1, std::max(y1-size, 0), std::min(x2, size), y2-size);
|
||||||
if(x2 > size) fillblendmap(node.branch->type[3], node.branch->children[3], size, val,
|
if(x2 > size) fillblendmap(node.branch->type[3], node.branch->children[3], size, val,
|
||||||
max(x1-size, 0), max(y1-size, 0), x2-size, y2-size);
|
std::max(x1-size, 0), std::max(y1-size, 0), x2-size, y2-size);
|
||||||
}
|
}
|
||||||
loopi(4) if(node.branch->type[i]!=BM_SOLID || node.branch->children[i].solid->val!=val) return;
|
loopi(4) if(node.branch->type[i]!=BM_SOLID || node.branch->children[i].solid->val!=val) return;
|
||||||
node.cleanup(type);
|
node.cleanup(type);
|
||||||
|
@ -276,11 +278,11 @@ static void fillblendmap(uchar &type, BlendMapNode &node, int size, uchar val, i
|
||||||
static void fillblendmap(int x, int y, int w, int h, uchar val)
|
static void fillblendmap(int x, int y, int w, int h, uchar val)
|
||||||
{
|
{
|
||||||
int bmsize = worldsize>>BM_SCALE,
|
int bmsize = worldsize>>BM_SCALE,
|
||||||
x1 = clamp(x, 0, bmsize),
|
x1 = std::clamp(x, 0, bmsize),
|
||||||
y1 = clamp(y, 0, bmsize),
|
y1 = std::clamp(y, 0, bmsize),
|
||||||
x2 = clamp(x+w, 0, bmsize),
|
x2 = std::clamp(x+w, 0, bmsize),
|
||||||
y2 = clamp(y+h, 0, bmsize);
|
y2 = std::clamp(y+h, 0, bmsize);
|
||||||
if(max(x1, y1) >= bmsize || min(x2, y2) <= 0 || x1>=x2 || y1>=y2) return;
|
if(std::max(x1, y1) >= bmsize || std::min(x2, y2) <= 0 || x1>=x2 || y1>=y2) return;
|
||||||
fillblendmap(blendmap.type, blendmap, bmsize, val, x1, y1, x2, y2);
|
fillblendmap(blendmap.type, blendmap, bmsize, val, x1, y1, x2, y2);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -292,16 +294,16 @@ static void invertblendmap(uchar &type, BlendMapNode &node, int size, int x1, in
|
||||||
if(y1 < size)
|
if(y1 < size)
|
||||||
{
|
{
|
||||||
if(x1 < size) invertblendmap(node.branch->type[0], node.branch->children[0], size,
|
if(x1 < size) invertblendmap(node.branch->type[0], node.branch->children[0], size,
|
||||||
x1, y1, min(x2, size), min(y2, size));
|
x1, y1, std::min(x2, size), std::min(y2, size));
|
||||||
if(x2 > size) invertblendmap(node.branch->type[1], node.branch->children[1], size,
|
if(x2 > size) invertblendmap(node.branch->type[1], node.branch->children[1], size,
|
||||||
max(x1-size, 0), y1, x2-size, min(y2, size));
|
std::max(x1-size, 0), y1, x2-size, std::min(y2, size));
|
||||||
}
|
}
|
||||||
if(y2 > size)
|
if(y2 > size)
|
||||||
{
|
{
|
||||||
if(x1 < size) invertblendmap(node.branch->type[2], node.branch->children[2], size,
|
if(x1 < size) invertblendmap(node.branch->type[2], node.branch->children[2], size,
|
||||||
x1, max(y1-size, 0), min(x2, size), y2-size);
|
x1, std::max(y1-size, 0), std::min(x2, size), y2-size);
|
||||||
if(x2 > size) invertblendmap(node.branch->type[3], node.branch->children[3], size,
|
if(x2 > size) invertblendmap(node.branch->type[3], node.branch->children[3], size,
|
||||||
max(x1-size, 0), max(y1-size, 0), x2-size, y2-size);
|
std::max(x1-size, 0), std::max(y1-size, 0), x2-size, y2-size);
|
||||||
}
|
}
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
@ -323,11 +325,11 @@ static void invertblendmap(uchar &type, BlendMapNode &node, int size, int x1, in
|
||||||
static void invertblendmap(int x, int y, int w, int h)
|
static void invertblendmap(int x, int y, int w, int h)
|
||||||
{
|
{
|
||||||
int bmsize = worldsize>>BM_SCALE,
|
int bmsize = worldsize>>BM_SCALE,
|
||||||
x1 = clamp(x, 0, bmsize),
|
x1 = std::clamp(x, 0, bmsize),
|
||||||
y1 = clamp(y, 0, bmsize),
|
y1 = std::clamp(y, 0, bmsize),
|
||||||
x2 = clamp(x+w, 0, bmsize),
|
x2 = std::clamp(x+w, 0, bmsize),
|
||||||
y2 = clamp(y+h, 0, bmsize);
|
y2 = std::clamp(y+h, 0, bmsize);
|
||||||
if(max(x1, y1) >= bmsize || min(x2, y2) <= 0 || x1>=x2 || y1>=y2) return;
|
if(std::max(x1, y1) >= bmsize || std::min(x2, y2) <= 0 || x1>=x2 || y1>=y2) return;
|
||||||
invertblendmap(blendmap.type, blendmap, bmsize, x1, y1, x2, y2);
|
invertblendmap(blendmap.type, blendmap, bmsize, x1, y1, x2, y2);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -405,10 +407,10 @@ static void blitblendmap(uchar &type, BlendMapNode &node, int bmx, int bmy, int
|
||||||
memset(node.image->data, val, sizeof(node.image->data));
|
memset(node.image->data, val, sizeof(node.image->data));
|
||||||
}
|
}
|
||||||
|
|
||||||
int x1 = clamp(sx - bmx, 0, bmsize), y1 = clamp(sy - bmy, 0, bmsize),
|
int x1 = std::clamp(sx - bmx, 0, bmsize), y1 = std::clamp(sy - bmy, 0, bmsize),
|
||||||
x2 = clamp(sx+sw - bmx, 0, bmsize), y2 = clamp(sy+sh - bmy, 0, bmsize);
|
x2 = std::clamp(sx+sw - bmx, 0, bmsize), y2 = std::clamp(sy+sh - bmy, 0, bmsize);
|
||||||
uchar *dst = &node.image->data[y1*BM_IMAGE_SIZE + x1];
|
uchar *dst = &node.image->data[y1*BM_IMAGE_SIZE + x1];
|
||||||
src += max(bmy - sy, 0)*sw + max(bmx - sx, 0);
|
src += std::max(bmy - sy, 0)*sw + std::max(bmx - sx, 0);
|
||||||
loopi(y2-y1)
|
loopi(y2-y1)
|
||||||
{
|
{
|
||||||
switch(smode)
|
switch(smode)
|
||||||
|
@ -418,19 +420,19 @@ static void blitblendmap(uchar &type, BlendMapNode &node, int bmx, int bmy, int
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case 2:
|
case 2:
|
||||||
loopi(x2 - x1) dst[i] = min(dst[i], src[i]);
|
loopi(x2 - x1) dst[i] = std::min(dst[i], src[i]);
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case 3:
|
case 3:
|
||||||
loopi(x2 - x1) dst[i] = max(dst[i], src[i]);
|
loopi(x2 - x1) dst[i] = std::max(dst[i], src[i]);
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case 4:
|
case 4:
|
||||||
loopi(x2 - x1) dst[i] = min(dst[i], uchar(0xFF - src[i]));
|
loopi(x2 - x1) dst[i] = std::min(dst[i], uchar(0xFF - src[i]));
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case 5:
|
case 5:
|
||||||
loopi(x2 - x1) dst[i] = max(dst[i], uchar(0xFF - src[i]));
|
loopi(x2 - x1) dst[i] = std::max(dst[i], uchar(0xFF - src[i]));
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
dst += BM_IMAGE_SIZE;
|
dst += BM_IMAGE_SIZE;
|
||||||
|
@ -441,7 +443,7 @@ static void blitblendmap(uchar &type, BlendMapNode &node, int bmx, int bmy, int
|
||||||
static void blitblendmap(uchar *src, int sx, int sy, int sw, int sh, int smode)
|
static void blitblendmap(uchar *src, int sx, int sy, int sw, int sh, int smode)
|
||||||
{
|
{
|
||||||
int bmsize = worldsize>>BM_SCALE;
|
int bmsize = worldsize>>BM_SCALE;
|
||||||
if(max(sx, sy) >= bmsize || min(sx+sw, sy+sh) <= 0 || min(sw, sh) <= 0) return;
|
if(std::max(sx, sy) >= bmsize || std::min(sx+sw, sy+sh) <= 0 || std::min(sw, sh) <= 0) return;
|
||||||
blitblendmap(blendmap.type, blendmap, 0, 0, bmsize, src, sx, sy, sw, sh, smode);
|
blitblendmap(blendmap.type, blendmap, 0, 0, bmsize, src, sx, sy, sw, sh, smode);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -511,8 +513,8 @@ static int calcblendlayer(uchar &type, BlendMapNode &node, int bmx, int bmy, int
|
||||||
if(type == BM_SOLID) val = node.solid->val;
|
if(type == BM_SOLID) val = node.solid->val;
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
int x1 = clamp(cx - bmx, 0, bmsize), y1 = clamp(cy - bmy, 0, bmsize),
|
int x1 = std::clamp(cx - bmx, 0, bmsize), y1 = std::clamp(cy - bmy, 0, bmsize),
|
||||||
x2 = clamp(cx+cw - bmx, 0, bmsize), y2 = clamp(cy+ch - bmy, 0, bmsize);
|
x2 = std::clamp(cx+cw - bmx, 0, bmsize), y2 = std::clamp(cy+ch - bmy, 0, bmsize);
|
||||||
uchar *src = &node.image->data[y1*BM_IMAGE_SIZE + x1];
|
uchar *src = &node.image->data[y1*BM_IMAGE_SIZE + x1];
|
||||||
val = src[0];
|
val = src[0];
|
||||||
loopi(y2-y1)
|
loopi(y2-y1)
|
||||||
|
@ -532,10 +534,10 @@ static int calcblendlayer(uchar &type, BlendMapNode &node, int bmx, int bmy, int
|
||||||
int calcblendlayer(int x1, int y1, int x2, int y2)
|
int calcblendlayer(int x1, int y1, int x2, int y2)
|
||||||
{
|
{
|
||||||
int bmsize = worldsize>>BM_SCALE,
|
int bmsize = worldsize>>BM_SCALE,
|
||||||
ux1 = max(x1, 0) >> BM_SCALE,
|
ux1 = std::max(x1, 0) >> BM_SCALE,
|
||||||
ux2 = (min(x2, worldsize) + (1<<BM_SCALE)-1) >> BM_SCALE,
|
ux2 = (std::min(x2, worldsize) + (1<<BM_SCALE)-1) >> BM_SCALE,
|
||||||
uy1 = max(y1, 0) >> BM_SCALE,
|
uy1 = std::max(y1, 0) >> BM_SCALE,
|
||||||
uy2 = (min(y2, worldsize) + (1<<BM_SCALE)-1) >> BM_SCALE;
|
uy2 = (std::min(y2, worldsize) + (1<<BM_SCALE)-1) >> BM_SCALE;
|
||||||
if(ux1 >= ux2 || uy1 >= uy2) return LAYER_TOP;
|
if(ux1 >= ux2 || uy1 >= uy2) return LAYER_TOP;
|
||||||
return calcblendlayer(blendmap.type, blendmap, 0, 0, bmsize, ux1, uy1, ux2-ux1, uy2-uy1);
|
return calcblendlayer(blendmap.type, blendmap, 0, 0, bmsize, ux1, uy1, ux2-ux1, uy2-uy1);
|
||||||
}
|
}
|
||||||
|
@ -659,7 +661,7 @@ struct BlendTexture
|
||||||
bool setup(int sz)
|
bool setup(int sz)
|
||||||
{
|
{
|
||||||
if(!tex) glGenTextures(1, &tex);
|
if(!tex) glGenTextures(1, &tex);
|
||||||
sz = min(sz, maxtexsize ? min(maxtexsize, hwtexsize) : hwtexsize);
|
sz = std::min(sz, maxtexsize ? std::min(maxtexsize, hwtexsize) : hwtexsize);
|
||||||
while(sz&(sz-1)) sz &= sz-1;
|
while(sz&(sz-1)) sz &= sz-1;
|
||||||
if(sz == size) return false;
|
if(sz == size) return false;
|
||||||
size = sz;
|
size = sz;
|
||||||
|
@ -722,11 +724,11 @@ static void renderblendtexture(uchar &type, BlendMapNode &node, int bmx, int bmy
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
int x1 = clamp(dx - bmx, 0, bmsize), y1 = clamp(dy - bmy, 0, bmsize),
|
int x1 = std::clamp(dx - bmx, 0, bmsize), y1 = std::clamp(dy - bmy, 0, bmsize),
|
||||||
x2 = clamp(dx+dw - bmx, 0, bmsize), y2 = clamp(dy+dh - bmy, 0, bmsize),
|
x2 = std::clamp(dx+dw - bmx, 0, bmsize), y2 = std::clamp(dy+dh - bmy, 0, bmsize),
|
||||||
tsize = 1<<(min(worldscale, 12)-BM_SCALE),
|
tsize = 1<<(std::min(worldscale, 12)-BM_SCALE),
|
||||||
step = tsize/dsize, stepw = (x2 - x1)/step, steph = (y2 - y1)/step;
|
step = tsize/dsize, stepw = (x2 - x1)/step, steph = (y2 - y1)/step;
|
||||||
dst += max(bmy - dy, 0)/step*dsize + max(bmx - dx, 0)/step;
|
dst += std::max(bmy - dy, 0)/step*dsize + std::max(bmx - dx, 0)/step;
|
||||||
if(type == BM_SOLID) loopi(steph)
|
if(type == BM_SOLID) loopi(steph)
|
||||||
{
|
{
|
||||||
memset(dst, node.solid->val, stepw);
|
memset(dst, node.solid->val, stepw);
|
||||||
|
@ -748,7 +750,7 @@ static void renderblendtexture(uchar &type, BlendMapNode &node, int bmx, int bmy
|
||||||
void renderblendtexture(uchar *dst, int dsize, int dx, int dy, int dw, int dh)
|
void renderblendtexture(uchar *dst, int dsize, int dx, int dy, int dw, int dh)
|
||||||
{
|
{
|
||||||
int bmsize = worldsize>>BM_SCALE;
|
int bmsize = worldsize>>BM_SCALE;
|
||||||
if(max(dx, dy) >= bmsize || min(dx+dw, dy+dh) <= 0 || min(dw, dh) <= 0) return;
|
if(std::max(dx, dy) >= bmsize || std::min(dx+dw, dy+dh) <= 0 || std::min(dw, dh) <= 0) return;
|
||||||
renderblendtexture(blendmap.type, blendmap, 0, 0, bmsize, dst, dsize, dx, dy, dw, dh);
|
renderblendtexture(blendmap.type, blendmap, 0, 0, bmsize, dst, dsize, dx, dy, dw, dh);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -779,10 +781,10 @@ static bool usesblendmap(uchar &type, BlendMapNode &node, int bmx, int bmy, int
|
||||||
bool usesblendmap(int x1, int y1, int x2, int y2)
|
bool usesblendmap(int x1, int y1, int x2, int y2)
|
||||||
{
|
{
|
||||||
int bmsize = worldsize>>BM_SCALE,
|
int bmsize = worldsize>>BM_SCALE,
|
||||||
ux1 = max(x1, 0) >> BM_SCALE,
|
ux1 = std::max(x1, 0) >> BM_SCALE,
|
||||||
ux2 = (min(x2, worldsize) + (1<<BM_SCALE)-1) >> BM_SCALE,
|
ux2 = (std::min(x2, worldsize) + (1<<BM_SCALE)-1) >> BM_SCALE,
|
||||||
uy1 = max(y1, 0) >> BM_SCALE,
|
uy1 = std::max(y1, 0) >> BM_SCALE,
|
||||||
uy2 = (min(y2, worldsize) + (1<<BM_SCALE)-1) >> BM_SCALE;
|
uy2 = (std::min(y2, worldsize) + (1<<BM_SCALE)-1) >> BM_SCALE;
|
||||||
if(ux1 >= ux2 || uy1 >= uy2) return false;
|
if(ux1 >= ux2 || uy1 >= uy2) return false;
|
||||||
return usesblendmap(blendmap.type, blendmap, 0, 0, bmsize, ux1, uy1, ux2-ux1, uy2-uy1);
|
return usesblendmap(blendmap.type, blendmap, 0, 0, bmsize, ux1, uy1, ux2-ux1, uy2-uy1);
|
||||||
}
|
}
|
||||||
|
@ -792,7 +794,7 @@ void bindblendtexture(const ivec &p)
|
||||||
loopv(blendtexs) if(blendtexs[i].contains(p))
|
loopv(blendtexs) if(blendtexs[i].contains(p))
|
||||||
{
|
{
|
||||||
BlendTexture &bt = blendtexs[i];
|
BlendTexture &bt = blendtexs[i];
|
||||||
int tsize = 1<<min(worldscale, 12);
|
int tsize = 1<<std::min(worldscale, 12);
|
||||||
GLOBALPARAMF(blendmapparams, bt.x, bt.y, 1.0f/tsize, 1.0f/tsize);
|
GLOBALPARAMF(blendmapparams, bt.x, bt.y, 1.0f/tsize, 1.0f/tsize);
|
||||||
glBindTexture(GL_TEXTURE_2D, bt.tex);
|
glBindTexture(GL_TEXTURE_2D, bt.tex);
|
||||||
break;
|
break;
|
||||||
|
@ -824,10 +826,10 @@ static void updateblendtextures(uchar &type, BlendMapNode &node, int bmx, int bm
|
||||||
|
|
||||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||||
|
|
||||||
int tx1 = max(bmx, ux)&~((0x1000>>BM_SCALE)-1),
|
int tx1 = std::max(bmx, ux)&~((0x1000>>BM_SCALE)-1),
|
||||||
tx2 = (min(bmx+bmsize, ux+uw) + (0x1000>>BM_SCALE)-1)&~((0x1000>>BM_SCALE)-1),
|
tx2 = (std::min(bmx+bmsize, ux+uw) + (0x1000>>BM_SCALE)-1)&~((0x1000>>BM_SCALE)-1),
|
||||||
ty1 = max(bmy, uy)&~((0x1000>>BM_SCALE)-1),
|
ty1 = std::max(bmy, uy)&~((0x1000>>BM_SCALE)-1),
|
||||||
ty2 = (min(bmy+bmsize, uy+uh) + (0x1000>>BM_SCALE)-1)&~((0x1000>>BM_SCALE)-1);
|
ty2 = (std::min(bmy+bmsize, uy+uh) + (0x1000>>BM_SCALE)-1)&~((0x1000>>BM_SCALE)-1);
|
||||||
for(int ty = ty1; ty < ty2; ty += 0x1000>>BM_SCALE) for(int tx = tx1; tx < tx2; tx += 0x1000>>BM_SCALE)
|
for(int ty = ty1; ty < ty2; ty += 0x1000>>BM_SCALE) for(int tx = tx1; tx < tx2; tx += 0x1000>>BM_SCALE)
|
||||||
{
|
{
|
||||||
BlendTexture *bt = nullptr;
|
BlendTexture *bt = nullptr;
|
||||||
|
@ -838,16 +840,16 @@ static void updateblendtextures(uchar &type, BlendMapNode &node, int bmx, int bm
|
||||||
bt->x = tx<<BM_SCALE;
|
bt->x = tx<<BM_SCALE;
|
||||||
bt->y = ty<<BM_SCALE;
|
bt->y = ty<<BM_SCALE;
|
||||||
}
|
}
|
||||||
bt->setup(1<<min(worldscale-BM_SCALE, blendtexsize));
|
bt->setup(1<<std::min(worldscale-BM_SCALE, blendtexsize));
|
||||||
int tsize = 1<<(min(worldscale, 12)-BM_SCALE),
|
int tsize = 1<<(std::min(worldscale, 12)-BM_SCALE),
|
||||||
ux1 = tx, ux2 = tx + tsize, uy1 = ty, uy2 = ty + tsize,
|
ux1 = tx, ux2 = tx + tsize, uy1 = ty, uy2 = ty + tsize,
|
||||||
step = tsize/bt->size;
|
step = tsize/bt->size;
|
||||||
if(!bt->valid)
|
if(!bt->valid)
|
||||||
{
|
{
|
||||||
ux1 = max(ux1, ux&~(step-1));
|
ux1 = std::max(ux1, ux&~(step-1));
|
||||||
ux2 = min(ux2, (ux+uw+step-1)&~(step-1));
|
ux2 = std::min(ux2, (ux+uw+step-1)&~(step-1));
|
||||||
uy1 = max(uy1, uy&~(step-1));
|
uy1 = std::max(uy1, uy&~(step-1));
|
||||||
uy2 = min(uy2, (uy+uh+step-1)&~(step-1));
|
uy2 = std::min(uy2, (uy+uh+step-1)&~(step-1));
|
||||||
bt->valid = true;
|
bt->valid = true;
|
||||||
}
|
}
|
||||||
uchar *data = bt->data + (uy1-ty)/step*bt->size + (ux1-tx)/step;
|
uchar *data = bt->data + (uy1-ty)/step*bt->size + (ux1-tx)/step;
|
||||||
|
@ -863,10 +865,10 @@ static void updateblendtextures(uchar &type, BlendMapNode &node, int bmx, int bm
|
||||||
void updateblendtextures(int x1, int y1, int x2, int y2)
|
void updateblendtextures(int x1, int y1, int x2, int y2)
|
||||||
{
|
{
|
||||||
int bmsize = worldsize>>BM_SCALE,
|
int bmsize = worldsize>>BM_SCALE,
|
||||||
ux1 = max(x1, 0) >> BM_SCALE,
|
ux1 = std::max(x1, 0) >> BM_SCALE,
|
||||||
ux2 = (min(x2, worldsize) + (1<<BM_SCALE)-1) >> BM_SCALE,
|
ux2 = (std::min(x2, worldsize) + (1<<BM_SCALE)-1) >> BM_SCALE,
|
||||||
uy1 = max(y1, 0) >> BM_SCALE,
|
uy1 = std::max(y1, 0) >> BM_SCALE,
|
||||||
uy2 = (min(y2, worldsize) + (1<<BM_SCALE)-1) >> BM_SCALE;
|
uy2 = (std::min(y2, worldsize) + (1<<BM_SCALE)-1) >> BM_SCALE;
|
||||||
if(ux1 >= ux2 || uy1 >= uy2) return;
|
if(ux1 >= ux2 || uy1 >= uy2) return;
|
||||||
updateblendtextures(blendmap.type, blendmap, 0, 0, bmsize, ux1, uy1, ux2-ux1, uy2-uy1);
|
updateblendtextures(blendmap.type, blendmap, 0, 0, bmsize, ux1, uy1, ux2-ux1, uy2-uy1);
|
||||||
}
|
}
|
||||||
|
@ -896,7 +898,7 @@ static void delblendbrush(const char *name)
|
||||||
delete brushes[i];
|
delete brushes[i];
|
||||||
brushes.remove(i--);
|
brushes.remove(i--);
|
||||||
}
|
}
|
||||||
curbrush = brushes.empty() ? -1 : clamp(curbrush, 0, brushes.length()-1);
|
curbrush = brushes.empty() ? -1 : std::clamp(curbrush, 0, brushes.length()-1);
|
||||||
}
|
}
|
||||||
|
|
||||||
COMMAND(delblendbrush, "s");
|
COMMAND(delblendbrush, "s");
|
||||||
|
@ -907,7 +909,7 @@ static void addblendbrush(const char *name, const char *imgname)
|
||||||
|
|
||||||
ImageData s;
|
ImageData s;
|
||||||
if(!loadimage(imgname, s)) { conoutf(CON_ERROR, "could not load blend brush image %s", imgname); return; }
|
if(!loadimage(imgname, s)) { conoutf(CON_ERROR, "could not load blend brush image %s", imgname); return; }
|
||||||
if(max(s.w, s.h) > (1<<12))
|
if(std::max(s.w, s.h) > (1<<12))
|
||||||
{
|
{
|
||||||
conoutf(CON_ERROR, "blend brush image size exceeded %dx%d pixels: %s", 1<<12, 1<<12, imgname);
|
conoutf(CON_ERROR, "blend brush image size exceeded %dx%d pixels: %s", 1<<12, 1<<12, imgname);
|
||||||
return;
|
return;
|
||||||
|
@ -973,7 +975,7 @@ ICOMMAND(rotateblendbrush, "i", (int *val),
|
||||||
if(!canpaintblendmap()) return;
|
if(!canpaintblendmap()) return;
|
||||||
|
|
||||||
BlendBrush *brush = brushes[curbrush];
|
BlendBrush *brush = brushes[curbrush];
|
||||||
const texrotation &r = texrotations[*val < 0 ? 3 : clamp(*val, 1, 7)];
|
const texrotation &r = texrotations[*val < 0 ? 3 : std::clamp(*val, 1, 7)];
|
||||||
brush->reorient(r.flipx, r.flipy, r.swapxy);
|
brush->reorient(r.flipx, r.flipy, r.swapxy);
|
||||||
});
|
});
|
||||||
|
|
||||||
|
@ -982,8 +984,8 @@ static void paintblendmap(bool msg)
|
||||||
if(!canpaintblendmap(true, false, msg)) return;
|
if(!canpaintblendmap(true, false, msg)) return;
|
||||||
|
|
||||||
BlendBrush *brush = brushes[curbrush];
|
BlendBrush *brush = brushes[curbrush];
|
||||||
int x = (int)floor(clamp(worldpos.x, 0.0f, float(worldsize))/(1<<BM_SCALE) - 0.5f*brush->w),
|
int x = (int)floor(std::clamp(worldpos.x, 0.0f, float(worldsize))/(1<<BM_SCALE) - 0.5f*brush->w),
|
||||||
y = (int)floor(clamp(worldpos.y, 0.0f, float(worldsize))/(1<<BM_SCALE) - 0.5f*brush->h);
|
y = (int)floor(std::clamp(worldpos.y, 0.0f, float(worldsize))/(1<<BM_SCALE) - 0.5f*brush->h);
|
||||||
blitblendmap(brush->data, x, y, brush->w, brush->h, blendpaintmode);
|
blitblendmap(brush->data, x, y, brush->w, brush->h, blendpaintmode);
|
||||||
previewblends(ivec((x-1)<<BM_SCALE, (y-1)<<BM_SCALE, 0),
|
previewblends(ivec((x-1)<<BM_SCALE, (y-1)<<BM_SCALE, 0),
|
||||||
ivec((x+brush->w+1)<<BM_SCALE, (y+brush->h+1)<<BM_SCALE, worldsize));
|
ivec((x+brush->w+1)<<BM_SCALE, (y+brush->h+1)<<BM_SCALE, worldsize));
|
||||||
|
@ -1091,12 +1093,12 @@ void renderblendbrush()
|
||||||
if(!blendpaintmode || !brushes.inrange(curbrush)) return;
|
if(!blendpaintmode || !brushes.inrange(curbrush)) return;
|
||||||
|
|
||||||
BlendBrush *brush = brushes[curbrush];
|
BlendBrush *brush = brushes[curbrush];
|
||||||
int x1 = (int)floor(clamp(worldpos.x, 0.0f, float(worldsize))/(1<<BM_SCALE) - 0.5f*brush->w) << BM_SCALE,
|
int x1 = (int)floor(std::clamp(worldpos.x, 0.0f, float(worldsize))/(1<<BM_SCALE) - 0.5f*brush->w) << BM_SCALE,
|
||||||
y1 = (int)floor(clamp(worldpos.y, 0.0f, float(worldsize))/(1<<BM_SCALE) - 0.5f*brush->h) << BM_SCALE,
|
y1 = (int)floor(std::clamp(worldpos.y, 0.0f, float(worldsize))/(1<<BM_SCALE) - 0.5f*brush->h) << BM_SCALE,
|
||||||
x2 = x1 + (brush->w << BM_SCALE),
|
x2 = x1 + (brush->w << BM_SCALE),
|
||||||
y2 = y1 + (brush->h << BM_SCALE);
|
y2 = y1 + (brush->h << BM_SCALE);
|
||||||
|
|
||||||
if(max(x1, y1) >= worldsize || min(x2, y2) <= 0 || x1>=x2 || y1>=y2) return;
|
if(std::max(x1, y1) >= worldsize || std::min(x2, y2) <= 0 || x1>=x2 || y1>=y2) return;
|
||||||
|
|
||||||
if(!brush->tex) brush->gentex();
|
if(!brush->tex) brush->gentex();
|
||||||
renderblendbrush(brush->tex, x1, y1, x2 - x1, y2 - y1);
|
renderblendbrush(brush->tex, x1, y1, x2 - x1, y2 - y1);
|
||||||
|
|
|
@ -6,6 +6,8 @@
|
||||||
#include <cctype>
|
#include <cctype>
|
||||||
#include <climits>
|
#include <climits>
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <sauerlib/encoding.hh>
|
#include <sauerlib/encoding.hh>
|
||||||
|
|
||||||
#include <shared/igame.hh>
|
#include <shared/igame.hh>
|
||||||
|
@ -653,7 +655,7 @@ void setvar(const char *name, int i, bool dofunc, bool doclamp)
|
||||||
{
|
{
|
||||||
GETVAR(id, name, );
|
GETVAR(id, name, );
|
||||||
OVERRIDEVAR(return, id->overrideval.i = *id->storage.i, , )
|
OVERRIDEVAR(return, id->overrideval.i = *id->storage.i, , )
|
||||||
if(doclamp) *id->storage.i = clamp(i, id->minval, id->maxval);
|
if(doclamp) *id->storage.i = std::clamp(i, id->minval, id->maxval);
|
||||||
else *id->storage.i = i;
|
else *id->storage.i = i;
|
||||||
if(dofunc) id->changed();
|
if(dofunc) id->changed();
|
||||||
}
|
}
|
||||||
|
@ -661,7 +663,7 @@ void setfvar(const char *name, float f, bool dofunc, bool doclamp)
|
||||||
{
|
{
|
||||||
_GETVAR(id, ID_FVAR, name, );
|
_GETVAR(id, ID_FVAR, name, );
|
||||||
OVERRIDEVAR(return, id->overrideval.f = *id->storage.f, , );
|
OVERRIDEVAR(return, id->overrideval.f = *id->storage.f, , );
|
||||||
if(doclamp) *id->storage.f = clamp(f, id->minvalf, id->maxvalf);
|
if(doclamp) *id->storage.f = std::clamp(f, id->minvalf, id->maxvalf);
|
||||||
else *id->storage.f = f;
|
else *id->storage.f = f;
|
||||||
if(dofunc) id->changed();
|
if(dofunc) id->changed();
|
||||||
}
|
}
|
||||||
|
@ -924,7 +926,7 @@ static char *conc(tagval *v, int n, bool space, const char *prefix, int prefixle
|
||||||
default: vlen[i] = 0; break;
|
default: vlen[i] = 0; break;
|
||||||
}
|
}
|
||||||
overflow:
|
overflow:
|
||||||
if(space) len += max(prefix ? i : i-1, 0);
|
if(space) len += std::max(prefix ? i : i-1, 0);
|
||||||
char *buf = newstring(len + numlen);
|
char *buf = newstring(len + numlen);
|
||||||
int offset = 0, numoffset = 0;
|
int offset = 0, numoffset = 0;
|
||||||
if(prefix)
|
if(prefix)
|
||||||
|
@ -2210,8 +2212,8 @@ static inline void callcommand(ident *id, tagval *args, int numargs, bool lookup
|
||||||
#ifndef STANDALONE
|
#ifndef STANDALONE
|
||||||
case 'D': if(++i < numargs) freearg(args[i]); addreleaseaction(id, args, i); fakeargs++; break;
|
case 'D': if(++i < numargs) freearg(args[i]); addreleaseaction(id, args, i); fakeargs++; break;
|
||||||
#endif
|
#endif
|
||||||
case 'C': { i = max(i+1, numargs); vector<char> buf; ((comfun1)id->fun)(conc(buf, args, i, true)); goto cleanup; }
|
case 'C': { i = std::max(i+1, numargs); vector<char> buf; ((comfun1)id->fun)(conc(buf, args, i, true)); goto cleanup; }
|
||||||
case 'V': i = max(i+1, numargs); ((comfunv)id->fun)(args, i); goto cleanup;
|
case 'V': i = std::max(i+1, numargs); ((comfunv)id->fun)(args, i); goto cleanup;
|
||||||
case '1': case '2': case '3': case '4': if(i+1 < numargs) { fmt -= *fmt-'0'+1; rep = true; } break;
|
case '1': case '2': case '3': case '4': if(i+1 < numargs) { fmt -= *fmt-'0'+1; rep = true; } break;
|
||||||
}
|
}
|
||||||
++i;
|
++i;
|
||||||
|
@ -3520,14 +3522,14 @@ COMMAND(at, "si1V");
|
||||||
|
|
||||||
void substr(char *s, int *start, int *count, int *numargs)
|
void substr(char *s, int *start, int *count, int *numargs)
|
||||||
{
|
{
|
||||||
int len = strlen(s), offset = clamp(*start, 0, len);
|
int len = strlen(s), offset = std::clamp(*start, 0, len);
|
||||||
commandret->setstr(newstring(&s[offset], *numargs >= 3 ? clamp(*count, 0, len - offset) : len - offset));
|
commandret->setstr(newstring(&s[offset], *numargs >= 3 ? std::clamp(*count, 0, len - offset) : len - offset));
|
||||||
}
|
}
|
||||||
COMMAND(substr, "siiN");
|
COMMAND(substr, "siiN");
|
||||||
|
|
||||||
void sublist(const char *s, int *skip, int *count, int *numargs)
|
void sublist(const char *s, int *skip, int *count, int *numargs)
|
||||||
{
|
{
|
||||||
int offset = max(*skip, 0), len = *numargs >= 3 ? max(*count, 0) : -1;
|
int offset = std::max(*skip, 0), len = *numargs >= 3 ? std::max(*count, 0) : -1;
|
||||||
loopi(offset) if(!parselist(s)) break;
|
loopi(offset) if(!parselist(s)) break;
|
||||||
if(len < 0) { if(offset > 0) skiplist(s); commandret->setstr(newstring(s)); return; }
|
if(len < 0) { if(offset > 0) skiplist(s); commandret->setstr(newstring(s)); return; }
|
||||||
const char *list = s, *start, *end, *qstart, *qend = s;
|
const char *list = s, *start, *end, *qstart, *qend = s;
|
||||||
|
@ -3798,7 +3800,7 @@ LISTMERGECMD(listunion, p.put(list, strlen(list)), elems, list, <);
|
||||||
|
|
||||||
void listsplice(const char *s, const char *vals, int *skip, int *count)
|
void listsplice(const char *s, const char *vals, int *skip, int *count)
|
||||||
{
|
{
|
||||||
int offset = max(*skip, 0), len = max(*count, 0);
|
int offset = std::max(*skip, 0), len = std::max(*count, 0);
|
||||||
const char *list = s, *start, *end, *qstart, *qend = s;
|
const char *list = s, *start, *end, *qstart, *qend = s;
|
||||||
loopi(offset) if(!parselist(s, start, end, qstart, qend)) break;
|
loopi(offset) if(!parselist(s, start, end, qstart, qend)) break;
|
||||||
vector<char> p;
|
vector<char> p;
|
||||||
|
@ -3942,7 +3944,7 @@ void sortlist(char *list, ident *x, ident *y, uint *body, uint *unique)
|
||||||
poparg(*y);
|
poparg(*y);
|
||||||
|
|
||||||
char *sorted = cstr;
|
char *sorted = cstr;
|
||||||
int sortedlen = totalunique + max(numunique - 1, 0);
|
int sortedlen = totalunique + std::max(numunique - 1, 0);
|
||||||
if(clen < sortedlen)
|
if(clen < sortedlen)
|
||||||
{
|
{
|
||||||
delete[] cstr;
|
delete[] cstr;
|
||||||
|
@ -4018,8 +4020,8 @@ MATHICMD(|, 0, );
|
||||||
MATHICMD(^~, 0, );
|
MATHICMD(^~, 0, );
|
||||||
MATHICMD(&~, 0, );
|
MATHICMD(&~, 0, );
|
||||||
MATHICMD(|~, 0, );
|
MATHICMD(|~, 0, );
|
||||||
MATHCMD("<<", i, int, val = val2 < 32 ? val << max(val2, 0) : 0, 0, );
|
MATHCMD("<<", i, int, val = val2 < 32 ? val << std::max(val2, 0) : 0, 0, );
|
||||||
MATHCMD(">>", i, int, val >>= clamp(val2, 0, 31), 0, );
|
MATHCMD(">>", i, int, val >>= std::clamp(val2, 0, 31), 0, );
|
||||||
|
|
||||||
MATHFCMD(+, 0, );
|
MATHFCMD(+, 0, );
|
||||||
MATHFCMD(*, 1, );
|
MATHFCMD(*, 1, );
|
||||||
|
@ -4152,12 +4154,12 @@ CASECOMMAND(cases, "s", const char *, args[0].getstr(), args[i].type == VAL_NULL
|
||||||
ICOMMAND(rnd, "ii", (int *a, int *b), intret(*a - *b > 0 ? rnd(*a - *b) + *b : *b));
|
ICOMMAND(rnd, "ii", (int *a, int *b), intret(*a - *b > 0 ? rnd(*a - *b) + *b : *b));
|
||||||
ICOMMAND(rndstr, "i", (int *len),
|
ICOMMAND(rndstr, "i", (int *len),
|
||||||
{
|
{
|
||||||
int n = clamp(*len, 0, 10000);
|
int n = std::clamp(*len, 0, 10000);
|
||||||
char *s = newstring(n);
|
char *s = newstring(n);
|
||||||
for(int i = 0; i < n;)
|
for(int i = 0; i < n;)
|
||||||
{
|
{
|
||||||
uint r = randomMT();
|
uint r = randomMT();
|
||||||
for(int j = min(i + 4, n); i < j; i++)
|
for(int j = std::min(i + 4, n); i < j; i++)
|
||||||
{
|
{
|
||||||
s[i] = (r%255) + 1;
|
s[i] = (r%255) + 1;
|
||||||
r /= 255;
|
r /= 255;
|
||||||
|
@ -4171,7 +4173,7 @@ ICOMMAND(tohex, "ii", (int *n, int *p),
|
||||||
{
|
{
|
||||||
const int len = 20;
|
const int len = 20;
|
||||||
char *buf = newstring(len);
|
char *buf = newstring(len);
|
||||||
nformatstring(buf, len, "0x%.*X", max(*p, 1), *n);
|
nformatstring(buf, len, "0x%.*X", std::max(*p, 1), *n);
|
||||||
stringret(buf);
|
stringret(buf);
|
||||||
});
|
});
|
||||||
|
|
||||||
|
@ -4247,8 +4249,8 @@ ICOMMAND(strreplace, "ssss", (char *s, char *o, char *n, char *n2), commandret->
|
||||||
void strsplice(const char *s, const char *vals, int *skip, int *count)
|
void strsplice(const char *s, const char *vals, int *skip, int *count)
|
||||||
{
|
{
|
||||||
int slen = strlen(s), vlen = strlen(vals),
|
int slen = strlen(s), vlen = strlen(vals),
|
||||||
offset = clamp(*skip, 0, slen),
|
offset = std::clamp(*skip, 0, slen),
|
||||||
len = clamp(*count, 0, slen - offset);
|
len = std::clamp(*count, 0, slen - offset);
|
||||||
char *p = newstring(slen - len + vlen);
|
char *p = newstring(slen - len + vlen);
|
||||||
if(offset) memcpy(p, s, offset);
|
if(offset) memcpy(p, s, offset);
|
||||||
if(vlen) memcpy(&p[offset], vals, vlen);
|
if(vlen) memcpy(&p[offset], vals, vlen);
|
||||||
|
@ -4271,7 +4273,7 @@ vector<sleepcmd> sleepcmds;
|
||||||
void addsleep(int *msec, char *cmd)
|
void addsleep(int *msec, char *cmd)
|
||||||
{
|
{
|
||||||
sleepcmd &s = sleepcmds.add();
|
sleepcmd &s = sleepcmds.add();
|
||||||
s.delay = max(*msec, 1);
|
s.delay = std::max(*msec, 1);
|
||||||
s.millis = lastmillis;
|
s.millis = lastmillis;
|
||||||
s.command = newstring(cmd);
|
s.command = newstring(cmd);
|
||||||
s.flags = identflags;
|
s.flags = identflags;
|
||||||
|
|
|
@ -93,13 +93,13 @@ static int conskip = 0, miniconskip = 0;
|
||||||
static void setconskip(int &skip, int filter, int n)
|
static void setconskip(int &skip, int filter, int n)
|
||||||
{
|
{
|
||||||
int offset = abs(n), dir = n < 0 ? -1 : 1;
|
int offset = abs(n), dir = n < 0 ? -1 : 1;
|
||||||
skip = clamp(skip, 0, conlines.length()-1);
|
skip = std::clamp(skip, 0, conlines.length()-1);
|
||||||
while(offset)
|
while(offset)
|
||||||
{
|
{
|
||||||
skip += dir;
|
skip += dir;
|
||||||
if(!conlines.inrange(skip))
|
if(!conlines.inrange(skip))
|
||||||
{
|
{
|
||||||
skip = clamp(skip, 0, conlines.length()-1);
|
skip = std::clamp(skip, 0, conlines.length()-1);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if(conlines[skip].type&filter) --offset;
|
if(conlines[skip].type&filter) --offset;
|
||||||
|
@ -113,7 +113,7 @@ ICOMMAND(clearconsole, "", (), { while(conlines.length()) delete[] conlines.pop(
|
||||||
|
|
||||||
static float drawconlines(int conskip, int confade, float conwidth, float conheight, float conoff, int filter, float y = 0, int dir = 1)
|
static float drawconlines(int conskip, int confade, float conwidth, float conheight, float conoff, int filter, float y = 0, int dir = 1)
|
||||||
{
|
{
|
||||||
int numl = conlines.length(), offset = min(conskip, numl);
|
int numl = conlines.length(), offset = std::min(conskip, numl);
|
||||||
|
|
||||||
if(confade)
|
if(confade)
|
||||||
{
|
{
|
||||||
|
@ -164,11 +164,11 @@ float renderfullconsole(float w, float h)
|
||||||
float renderconsole(float w, float h, float abovehud)
|
float renderconsole(float w, float h, float abovehud)
|
||||||
{
|
{
|
||||||
float conpad = FONTH/2,
|
float conpad = FONTH/2,
|
||||||
conheight = min(float(FONTH*consize), h - 2*conpad),
|
conheight = std::min(float(FONTH*consize), h - 2*conpad),
|
||||||
conwidth = w - 2*conpad - game::clipconsole(w, h);
|
conwidth = w - 2*conpad - game::clipconsole(w, h);
|
||||||
float y = drawconlines(conskip, confade, conwidth, conheight, conpad, confilter);
|
float y = drawconlines(conskip, confade, conwidth, conheight, conpad, confilter);
|
||||||
if(miniconsize && miniconwidth)
|
if(miniconsize && miniconwidth)
|
||||||
drawconlines(miniconskip, miniconfade, (miniconwidth*(w - 2*conpad))/100, min(float(FONTH*miniconsize), abovehud - y), conpad, miniconfilter, abovehud, -1);
|
drawconlines(miniconskip, miniconfade, (miniconwidth*(w - 2*conpad))/100, std::min(float(FONTH*miniconsize), abovehud - y), conpad, miniconfilter, abovehud, -1);
|
||||||
return y;
|
return y;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -474,7 +474,7 @@ static bool consoleinput(const char *str, int len)
|
||||||
|
|
||||||
resetcomplete();
|
resetcomplete();
|
||||||
int cmdlen = (int)strlen(commandbuf), cmdspace = int(sizeof(commandbuf)) - (cmdlen+1);
|
int cmdlen = (int)strlen(commandbuf), cmdspace = int(sizeof(commandbuf)) - (cmdlen+1);
|
||||||
len = min(len, cmdspace);
|
len = std::min(len, cmdspace);
|
||||||
if(commandpos<0)
|
if(commandpos<0)
|
||||||
{
|
{
|
||||||
memcpy(&commandbuf[cmdlen], str, len);
|
memcpy(&commandbuf[cmdlen], str, len);
|
||||||
|
@ -798,7 +798,7 @@ static void complete(char *s, int maxlen, const char *cmdprefix)
|
||||||
DELETEA(lastcomplete);
|
DELETEA(lastcomplete);
|
||||||
if(nextcomplete)
|
if(nextcomplete)
|
||||||
{
|
{
|
||||||
cmdlen = min(cmdlen, maxlen-1);
|
cmdlen = std::min(cmdlen, maxlen-1);
|
||||||
if(cmdlen) memmove(s, cmdprefix, cmdlen);
|
if(cmdlen) memmove(s, cmdprefix, cmdlen);
|
||||||
copystring(&s[cmdlen], nextcomplete, maxlen-cmdlen);
|
copystring(&s[cmdlen], nextcomplete, maxlen-cmdlen);
|
||||||
lastcomplete = newstring(nextcomplete);
|
lastcomplete = newstring(nextcomplete);
|
||||||
|
|
|
@ -67,8 +67,8 @@ struct skelbih
|
||||||
Texture *tex = s[t.mesh].tex; \
|
Texture *tex = s[t.mesh].tex; \
|
||||||
if(tex->type&Texture::ALPHA && (tex->alphamask || loadalphamask(tex))) \
|
if(tex->type&Texture::ALPHA && (tex->alphamask || loadalphamask(tex))) \
|
||||||
{ \
|
{ \
|
||||||
int si = clamp(int(tex->xs * (va.tc.x + u*(vb.tc.x - va.tc.x) + v*(vc.tc.x - va.tc.x))), 0, tex->xs-1), \
|
int si = std::clamp(int(tex->xs * (va.tc.x + u*(vb.tc.x - va.tc.x) + v*(vc.tc.x - va.tc.x))), 0, tex->xs-1), \
|
||||||
ti = clamp(int(tex->ys * (va.tc.y + u*(vb.tc.y - va.tc.y) + v*(vc.tc.y - va.tc.y))), 0, tex->ys-1); \
|
ti = std::clamp(int(tex->ys * (va.tc.y + u*(vb.tc.y - va.tc.y) + v*(vc.tc.y - va.tc.y))), 0, tex->ys-1); \
|
||||||
if(!(tex->alphamask[ti*((tex->xs+7)/8) + si/8] & (1<<(si%8)))) return false; \
|
if(!(tex->alphamask[ti*((tex->xs+7)/8) + si/8] & (1<<(si%8)))) return false; \
|
||||||
} \
|
} \
|
||||||
} \
|
} \
|
||||||
|
|
|
@ -1,5 +1,7 @@
|
||||||
#include "light.hh"
|
#include "light.hh"
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
#include <shared/igame.hh>
|
#include <shared/igame.hh>
|
||||||
|
|
||||||
|
@ -680,7 +682,7 @@ static void lightreaching(const vec &target, vec &color, vec &dir, bool fast = f
|
||||||
if(e.attached && e.attached->type==ET_SPOTLIGHT)
|
if(e.attached && e.attached->type==ET_SPOTLIGHT)
|
||||||
{
|
{
|
||||||
vec spot = vec(e.attached->o).sub(e.o).normalize();
|
vec spot = vec(e.attached->o).sub(e.o).normalize();
|
||||||
float spotatten = 1 - (1 - ray.dot(spot)) / (1 - cos360(clamp(int(e.attached->attr1), 1, 89)));
|
float spotatten = 1 - (1 - ray.dot(spot)) / (1 - cos360(std::clamp(int(e.attached->attr1), 1, 89)));
|
||||||
if(spotatten <= 0) continue;
|
if(spotatten <= 0) continue;
|
||||||
intensity *= spotatten;
|
intensity *= spotatten;
|
||||||
}
|
}
|
||||||
|
|
|
@ -34,7 +34,7 @@ static void renderlightning(Texture *tex, const vec &o, const vec &d, float sz)
|
||||||
vec step(d);
|
vec step(d);
|
||||||
step.sub(o);
|
step.sub(o);
|
||||||
float len = step.magnitude();
|
float len = step.magnitude();
|
||||||
int numsteps = clamp(int(ceil(len/LIGHTNINGSTEP)), 2, MAXLIGHTNINGSTEPS);
|
int numsteps = std::clamp(int(ceil(len/LIGHTNINGSTEP)), 2, MAXLIGHTNINGSTEPS);
|
||||||
step.div(numsteps+1);
|
step.div(numsteps+1);
|
||||||
int jitteroffset = detrnd(int(d.x+d.y+d.z), MAXLIGHTNINGSTEPS);
|
int jitteroffset = detrnd(int(d.x+d.y+d.z), MAXLIGHTNINGSTEPS);
|
||||||
vec cur(o), up, right;
|
vec cur(o), up, right;
|
||||||
|
@ -44,7 +44,7 @@ static void renderlightning(Texture *tex, const vec &o, const vec &d, float sz)
|
||||||
right.normalize();
|
right.normalize();
|
||||||
float scroll = -float(lastmillis%lnscrollmillis)/lnscrollmillis,
|
float scroll = -float(lastmillis%lnscrollmillis)/lnscrollmillis,
|
||||||
scrollscale = lnscrollscale*(LIGHTNINGSTEP*tex->ys)/(sz*tex->xs),
|
scrollscale = lnscrollscale*(LIGHTNINGSTEP*tex->ys)/(sz*tex->xs),
|
||||||
blend = pow(clamp(float(lastmillis - lastlnjitter)/lnjittermillis, 0.0f, 1.0f), lnblendpower),
|
blend = pow(std::clamp(float(lastmillis - lastlnjitter)/lnjittermillis, 0.0f, 1.0f), lnblendpower),
|
||||||
jitter0 = (1-blend)*lnjitterscale*sz/lnjitterradius, jitter1 = blend*lnjitterscale*sz/lnjitterradius;
|
jitter0 = (1-blend)*lnjitterscale*sz/lnjitterradius, jitter1 = blend*lnjitterscale*sz/lnjitterradius;
|
||||||
gle::begin(GL_TRIANGLE_STRIP);
|
gle::begin(GL_TRIANGLE_STRIP);
|
||||||
loopj(numsteps)
|
loopj(numsteps)
|
||||||
|
|
|
@ -4,6 +4,8 @@
|
||||||
|
|
||||||
#include <cassert>
|
#include <cassert>
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <sauerlib/encoding.hh>
|
#include <sauerlib/encoding.hh>
|
||||||
|
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
|
@ -518,8 +520,8 @@ VARF(fullscreen, 0, 1, 1, setfullscreen(fullscreen!=0));
|
||||||
|
|
||||||
static void screenres(int w, int h)
|
static void screenres(int w, int h)
|
||||||
{
|
{
|
||||||
scr_w = clamp(w, SCR_MINW, SCR_MAXW);
|
scr_w = std::clamp(w, SCR_MINW, SCR_MAXW);
|
||||||
scr_h = clamp(h, SCR_MINH, SCR_MAXH);
|
scr_h = std::clamp(h, SCR_MINH, SCR_MAXH);
|
||||||
if(screen)
|
if(screen)
|
||||||
{
|
{
|
||||||
scr_w = min(scr_w, desktopw);
|
scr_w = min(scr_w, desktopw);
|
||||||
|
@ -850,8 +852,8 @@ static void checkinput()
|
||||||
SDL_GetWindowSize(screen, &screenw, &screenh);
|
SDL_GetWindowSize(screen, &screenw, &screenh);
|
||||||
if(!(SDL_GetWindowFlags(screen) & SDL_WINDOW_FULLSCREEN))
|
if(!(SDL_GetWindowFlags(screen) & SDL_WINDOW_FULLSCREEN))
|
||||||
{
|
{
|
||||||
scr_w = clamp(screenw, SCR_MINW, SCR_MAXW);
|
scr_w = std::clamp(screenw, SCR_MINW, SCR_MAXW);
|
||||||
scr_h = clamp(screenh, SCR_MINH, SCR_MAXH);
|
scr_h = std::clamp(screenh, SCR_MINH, SCR_MAXH);
|
||||||
}
|
}
|
||||||
gl_resize();
|
gl_resize();
|
||||||
break;
|
break;
|
||||||
|
@ -1102,15 +1104,15 @@ int main(int argc, char **argv)
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case 'g': break;
|
case 'g': break;
|
||||||
case 'w': scr_w = clamp(atoi(&argv[i][2]), SCR_MINW, SCR_MAXW); if(!findarg(argc, argv, "-h")) scr_h = -1; break;
|
case 'w': scr_w = std::clamp(atoi(&argv[i][2]), SCR_MINW, SCR_MAXW); if(!findarg(argc, argv, "-h")) scr_h = -1; break;
|
||||||
case 'h': scr_h = clamp(atoi(&argv[i][2]), SCR_MINH, SCR_MAXH); if(!findarg(argc, argv, "-w")) scr_w = -1; break;
|
case 'h': scr_h = std::clamp(atoi(&argv[i][2]), SCR_MINH, SCR_MAXH); if(!findarg(argc, argv, "-w")) scr_w = -1; break;
|
||||||
case 'f': fullscreen = atoi(&argv[i][2]); break;
|
case 'f': fullscreen = atoi(&argv[i][2]); break;
|
||||||
case 'x': initscript = &argv[i][2]; break;
|
case 'x': initscript = &argv[i][2]; break;
|
||||||
default: break;
|
default: break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
numcpus = clamp(SDL_GetCPUCount(), 1, 16);
|
numcpus = std::clamp(SDL_GetCPUCount(), 1, 16);
|
||||||
|
|
||||||
printf("init: sdl\n");
|
printf("init: sdl\n");
|
||||||
|
|
||||||
|
|
|
@ -5,6 +5,8 @@
|
||||||
#include <cassert>
|
#include <cassert>
|
||||||
#include <climits>
|
#include <climits>
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
#include <shared/igame.hh>
|
#include <shared/igame.hh>
|
||||||
|
|
||||||
|
@ -280,9 +282,9 @@ ivec lu;
|
||||||
int lusize;
|
int lusize;
|
||||||
cube &lookupcube(const ivec &to, int tsize, ivec &ro, int &rsize)
|
cube &lookupcube(const ivec &to, int tsize, ivec &ro, int &rsize)
|
||||||
{
|
{
|
||||||
int tx = clamp(to.x, 0, worldsize-1),
|
int tx = std::clamp(to.x, 0, worldsize-1),
|
||||||
ty = clamp(to.y, 0, worldsize-1),
|
ty = std::clamp(to.y, 0, worldsize-1),
|
||||||
tz = clamp(to.z, 0, worldsize-1);
|
tz = std::clamp(to.z, 0, worldsize-1);
|
||||||
int scale = worldscale-1, csize = abs(tsize);
|
int scale = worldscale-1, csize = abs(tsize);
|
||||||
cube *c = &worldroot[octastep(tx, ty, tz, scale)];
|
cube *c = &worldroot[octastep(tx, ty, tz, scale)];
|
||||||
if(!(csize>>scale)) do
|
if(!(csize>>scale)) do
|
||||||
|
@ -483,10 +485,10 @@ bool subdividecube(cube &c, bool fullcheck, bool brighten)
|
||||||
{
|
{
|
||||||
ch[i].texture[j] = c.texture[j];
|
ch[i].texture[j] = c.texture[j];
|
||||||
int rd = (i>>R[d])&1, cd = (i>>C[d])&1, dd = (i>>D[d])&1;
|
int rd = (i>>R[d])&1, cd = (i>>C[d])&1, dd = (i>>D[d])&1;
|
||||||
edgeset(cubeedge(ch[i], d, 0, 0), z, clamp(e[rd][cd] - dd*8, 0, 8));
|
edgeset(cubeedge(ch[i], d, 0, 0), z, std::clamp(e[rd][cd] - dd*8, 0, 8));
|
||||||
edgeset(cubeedge(ch[i], d, 1, 0), z, clamp(e[1+rd][cd] - dd*8, 0, 8));
|
edgeset(cubeedge(ch[i], d, 1, 0), z, std::clamp(e[1+rd][cd] - dd*8, 0, 8));
|
||||||
edgeset(cubeedge(ch[i], d, 0, 1), z, clamp(e[rd][1+cd] - dd*8, 0, 8));
|
edgeset(cubeedge(ch[i], d, 0, 1), z, std::clamp(e[rd][1+cd] - dd*8, 0, 8));
|
||||||
edgeset(cubeedge(ch[i], d, 1, 1), z, clamp(e[1+rd][1+cd] - dd*8, 0, 8));
|
edgeset(cubeedge(ch[i], d, 1, 1), z, std::clamp(e[1+rd][1+cd] - dd*8, 0, 8));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -1,6 +1,8 @@
|
||||||
#ifndef ENGINE_OCTA_HH
|
#ifndef ENGINE_OCTA_HH
|
||||||
#define ENGINE_OCTA_HH
|
#define ENGINE_OCTA_HH
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <shared/gl.hh>
|
#include <shared/gl.hh>
|
||||||
#include <shared/geom.hh>
|
#include <shared/geom.hh>
|
||||||
|
|
||||||
|
@ -26,9 +28,9 @@ struct selinfo
|
||||||
if(o.x < 0) { s.x -= (grid - 1 - o.x)/grid; o.x = 0; }
|
if(o.x < 0) { s.x -= (grid - 1 - o.x)/grid; o.x = 0; }
|
||||||
if(o.y < 0) { s.y -= (grid - 1 - o.y)/grid; o.y = 0; }
|
if(o.y < 0) { s.y -= (grid - 1 - o.y)/grid; o.y = 0; }
|
||||||
if(o.z < 0) { s.z -= (grid - 1 - o.z)/grid; o.z = 0; }
|
if(o.z < 0) { s.z -= (grid - 1 - o.z)/grid; o.z = 0; }
|
||||||
s.x = clamp(s.x, 0, (worldsize - o.x)/grid);
|
s.x = std::clamp(s.x, 0, (worldsize - o.x)/grid);
|
||||||
s.y = clamp(s.y, 0, (worldsize - o.y)/grid);
|
s.y = std::clamp(s.y, 0, (worldsize - o.y)/grid);
|
||||||
s.z = clamp(s.z, 0, (worldsize - o.z)/grid);
|
s.z = std::clamp(s.z, 0, (worldsize - o.z)/grid);
|
||||||
return s.x > 0 && s.y > 0 && s.z > 0;
|
return s.x > 0 && s.y > 0 && s.z > 0;
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
|
@ -1,6 +1,7 @@
|
||||||
#include "octaedit.hh"
|
#include "octaedit.hh"
|
||||||
|
|
||||||
#include <new>
|
#include <new>
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <zlib.h>
|
#include <zlib.h>
|
||||||
|
|
||||||
|
@ -445,7 +446,7 @@ void rendereditcursor()
|
||||||
if(!insideworld(w))
|
if(!insideworld(w))
|
||||||
{
|
{
|
||||||
wdist = 0;
|
wdist = 0;
|
||||||
loopi(3) w[i] = clamp(player->o[i], 0.0f, float(worldsize));
|
loopi(3) w[i] = std::clamp(player->o[i], 0.0f, float(worldsize));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
cube *c = &lookupcube(ivec(w));
|
cube *c = &lookupcube(ivec(w));
|
||||||
|
@ -1656,7 +1657,7 @@ namespace hmap
|
||||||
*x += MAXBRUSH2 - brushx + 1; // +1 for automatic padding
|
*x += MAXBRUSH2 - brushx + 1; // +1 for automatic padding
|
||||||
*y += MAXBRUSH2 - brushy + 1;
|
*y += MAXBRUSH2 - brushy + 1;
|
||||||
if(*x<0 || *y<0 || *x>=MAXBRUSH || *y>=MAXBRUSH) return;
|
if(*x<0 || *y<0 || *x>=MAXBRUSH || *y>=MAXBRUSH) return;
|
||||||
brush[*x][*y] = clamp(*v, 0, 8);
|
brush[*x][*y] = std::clamp(*v, 0, 8);
|
||||||
paintbrush = paintbrush || (brush[*x][*y] > 0);
|
paintbrush = paintbrush || (brush[*x][*y] > 0);
|
||||||
brushmaxx = min(MAXBRUSH-1, max(brushmaxx, *x+1));
|
brushmaxx = min(MAXBRUSH-1, max(brushmaxx, *x+1));
|
||||||
brushmaxy = min(MAXBRUSH-1, max(brushmaxy, *y+1));
|
brushmaxy = min(MAXBRUSH-1, max(brushmaxy, *y+1));
|
||||||
|
@ -1943,8 +1944,8 @@ namespace hmap
|
||||||
memset(flags, 0, sizeof flags);
|
memset(flags, 0, sizeof flags);
|
||||||
|
|
||||||
selecting = true;
|
selecting = true;
|
||||||
select(clamp(MAXBRUSH2-cx, bmx, bnx),
|
select(std::clamp(MAXBRUSH2-cx, bmx, bnx),
|
||||||
clamp(MAXBRUSH2-cy, bmy, bny),
|
std::clamp(MAXBRUSH2-cy, bmy, bny),
|
||||||
dc ? gz : hws - gz);
|
dc ? gz : hws - gz);
|
||||||
selecting = false;
|
selecting = false;
|
||||||
if(paintme)
|
if(paintme)
|
||||||
|
@ -2261,7 +2262,7 @@ static void vrotate(int *n)
|
||||||
if(noedit()) return;
|
if(noedit()) return;
|
||||||
VSlot ds;
|
VSlot ds;
|
||||||
ds.changed = 1<<VSLOT_ROTATION;
|
ds.changed = 1<<VSLOT_ROTATION;
|
||||||
ds.rotation = usevdelta ? *n : clamp(*n, 0, 7);
|
ds.rotation = usevdelta ? *n : std::clamp(*n, 0, 7);
|
||||||
mpeditvslot(usevdelta, ds, allfaces, sel, true);
|
mpeditvslot(usevdelta, ds, allfaces, sel, true);
|
||||||
}
|
}
|
||||||
COMMAND(vrotate, "i");
|
COMMAND(vrotate, "i");
|
||||||
|
@ -2304,7 +2305,7 @@ static void vscale(float *scale)
|
||||||
if(noedit()) return;
|
if(noedit()) return;
|
||||||
VSlot ds;
|
VSlot ds;
|
||||||
ds.changed = 1<<VSLOT_SCALE;
|
ds.changed = 1<<VSLOT_SCALE;
|
||||||
ds.scale = *scale <= 0 ? 1 : (usevdelta ? *scale : clamp(*scale, 1/8.0f, 8.0f));
|
ds.scale = *scale <= 0 ? 1 : (usevdelta ? *scale : std::clamp(*scale, 1/8.0f, 8.0f));
|
||||||
mpeditvslot(usevdelta, ds, allfaces, sel, true);
|
mpeditvslot(usevdelta, ds, allfaces, sel, true);
|
||||||
}
|
}
|
||||||
COMMAND(vscale, "f");
|
COMMAND(vscale, "f");
|
||||||
|
@ -2347,8 +2348,8 @@ static void valpha(float *front, float *back)
|
||||||
if(noedit()) return;
|
if(noedit()) return;
|
||||||
VSlot ds;
|
VSlot ds;
|
||||||
ds.changed = 1<<VSLOT_ALPHA;
|
ds.changed = 1<<VSLOT_ALPHA;
|
||||||
ds.alphafront = clamp(*front, 0.0f, 1.0f);
|
ds.alphafront = std::clamp(*front, 0.0f, 1.0f);
|
||||||
ds.alphaback = clamp(*back, 0.0f, 1.0f);
|
ds.alphaback = std::clamp(*back, 0.0f, 1.0f);
|
||||||
mpeditvslot(usevdelta, ds, allfaces, sel, true);
|
mpeditvslot(usevdelta, ds, allfaces, sel, true);
|
||||||
}
|
}
|
||||||
COMMAND(valpha, "ff");
|
COMMAND(valpha, "ff");
|
||||||
|
@ -2364,7 +2365,7 @@ static void vcolor(float *r, float *g, float *b)
|
||||||
if(noedit()) return;
|
if(noedit()) return;
|
||||||
VSlot ds;
|
VSlot ds;
|
||||||
ds.changed = 1<<VSLOT_COLOR;
|
ds.changed = 1<<VSLOT_COLOR;
|
||||||
ds.colorscale = vec(clamp(*r, 0.0f, 2.0f), clamp(*g, 0.0f, 2.0f), clamp(*b, 0.0f, 2.0f));
|
ds.colorscale = vec(std::clamp(*r, 0.0f, 2.0f), std::clamp(*g, 0.0f, 2.0f), std::clamp(*b, 0.0f, 2.0f));
|
||||||
mpeditvslot(usevdelta, ds, allfaces, sel, true);
|
mpeditvslot(usevdelta, ds, allfaces, sel, true);
|
||||||
}
|
}
|
||||||
COMMAND(vcolor, "fff");
|
COMMAND(vcolor, "fff");
|
||||||
|
@ -2380,9 +2381,9 @@ static void vrefract(float *k, float *r, float *g, float *b)
|
||||||
if(noedit()) return;
|
if(noedit()) return;
|
||||||
VSlot ds;
|
VSlot ds;
|
||||||
ds.changed = 1<<VSLOT_REFRACT;
|
ds.changed = 1<<VSLOT_REFRACT;
|
||||||
ds.refractscale = clamp(*k, 0.0f, 1.0f);
|
ds.refractscale = std::clamp(*k, 0.0f, 1.0f);
|
||||||
if(ds.refractscale > 0 && (*r > 0 || *g > 0 || *b > 0))
|
if(ds.refractscale > 0 && (*r > 0 || *g > 0 || *b > 0))
|
||||||
ds.refractcolor = vec(clamp(*r, 0.0f, 1.0f), clamp(*g, 0.0f, 1.0f), clamp(*b, 0.0f, 1.0f));
|
ds.refractcolor = vec(std::clamp(*r, 0.0f, 1.0f), std::clamp(*g, 0.0f, 1.0f), std::clamp(*b, 0.0f, 1.0f));
|
||||||
else
|
else
|
||||||
ds.refractcolor = vec(1, 1, 1);
|
ds.refractcolor = vec(1, 1, 1);
|
||||||
mpeditvslot(usevdelta, ds, allfaces, sel, true);
|
mpeditvslot(usevdelta, ds, allfaces, sel, true);
|
||||||
|
@ -2546,7 +2547,7 @@ static void edittex_(int *dir)
|
||||||
if(texmru.empty()) return;
|
if(texmru.empty()) return;
|
||||||
texpaneltimer = 5000;
|
texpaneltimer = 5000;
|
||||||
if(!(lastsel==sel)) tofronttex();
|
if(!(lastsel==sel)) tofronttex();
|
||||||
curtexindex = clamp(curtexindex<0 ? 0 : curtexindex+*dir, 0, texmru.length()-1);
|
curtexindex = std::clamp(curtexindex<0 ? 0 : curtexindex+*dir, 0, texmru.length()-1);
|
||||||
edittex(texmru[curtexindex], false);
|
edittex(texmru[curtexindex], false);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -4,6 +4,8 @@
|
||||||
|
|
||||||
#include <cassert>
|
#include <cassert>
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
#include <shared/glemu.hh>
|
#include <shared/glemu.hh>
|
||||||
#include <shared/igame.hh>
|
#include <shared/igame.hh>
|
||||||
|
@ -840,7 +842,7 @@ ushort encodenormal(const vec &n)
|
||||||
{
|
{
|
||||||
if(n.iszero()) return 0;
|
if(n.iszero()) return 0;
|
||||||
int yaw = int(-atan2(n.x, n.y)/RAD), pitch = int(asin(n.z)/RAD);
|
int yaw = int(-atan2(n.x, n.y)/RAD), pitch = int(asin(n.z)/RAD);
|
||||||
return ushort(clamp(pitch + 90, 0, 180)*360 + (yaw < 0 ? yaw%360 + 360 : yaw%360) + 1);
|
return ushort(std::clamp(pitch + 90, 0, 180)*360 + (yaw < 0 ? yaw%360 + 360 : yaw%360) + 1);
|
||||||
}
|
}
|
||||||
|
|
||||||
static vec decodenormal(ushort norm)
|
static vec decodenormal(ushort norm)
|
||||||
|
@ -1591,7 +1593,7 @@ static int updateva(cube *c, const ivec &co, int size, int csi)
|
||||||
int tcount = count + (csi <= MAXMERGELEVEL ? vamerges[csi].length() : 0);
|
int tcount = count + (csi <= MAXMERGELEVEL ? vamerges[csi].length() : 0);
|
||||||
if(tcount > vafacemax || (tcount >= vafacemin && size >= vacubesize) || size == min(0x1000, worldsize/2))
|
if(tcount > vafacemax || (tcount >= vafacemin && size >= vacubesize) || size == min(0x1000, worldsize/2))
|
||||||
{
|
{
|
||||||
loadprogress = clamp(recalcprogress/float(allocnodes), 0.0f, 1.0f);
|
loadprogress = std::clamp(recalcprogress/float(allocnodes), 0.0f, 1.0f);
|
||||||
setva(c[i], o, size, csi);
|
setva(c[i], o, size, csi);
|
||||||
if(c[i].ext && c[i].ext->va)
|
if(c[i].ext && c[i].ext->va)
|
||||||
{
|
{
|
||||||
|
|
|
@ -7,6 +7,8 @@
|
||||||
|
|
||||||
#include <cassert>
|
#include <cassert>
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
#include <shared/igame.hh>
|
#include <shared/igame.hh>
|
||||||
|
|
||||||
|
@ -455,7 +457,7 @@ static bool ellipseboxcollide(physent *d, const vec &dir, const vec &o, const ve
|
||||||
yo.rotate_around_z(-yaw*RAD);
|
yo.rotate_around_z(-yaw*RAD);
|
||||||
yo.sub(center);
|
yo.sub(center);
|
||||||
|
|
||||||
float dx = clamp(yo.x, -xr, xr) - yo.x, dy = clamp(yo.y, -yr, yr) - yo.y,
|
float dx = std::clamp(yo.x, -xr, xr) - yo.x, dy = std::clamp(yo.y, -yr, yr) - yo.y,
|
||||||
dist = sqrtf(dx*dx + dy*dy) - d->radius;
|
dist = sqrtf(dx*dx + dy*dy) - d->radius;
|
||||||
if(dist < 0)
|
if(dist < 0)
|
||||||
{
|
{
|
||||||
|
@ -1828,12 +1830,12 @@ static void modifygravity(physent *pl, bool water, int curtime)
|
||||||
if(water || pl->physstate >= PHYS_SLOPE)
|
if(water || pl->physstate >= PHYS_SLOPE)
|
||||||
{
|
{
|
||||||
float fric = water ? 2.0f : 6.0f,
|
float fric = water ? 2.0f : 6.0f,
|
||||||
c = water ? 1.0f : clamp((pl->floor.z - SLOPEZ)/(FLOORZ-SLOPEZ), 0.0f, 1.0f);
|
c = water ? 1.0f : std::clamp((pl->floor.z - SLOPEZ)/(FLOORZ-SLOPEZ), 0.0f, 1.0f);
|
||||||
pl->falling.mul(pow(1 - c/fric, curtime/20.0f));
|
pl->falling.mul(pow(1 - c/fric, curtime/20.0f));
|
||||||
// old fps friction
|
// old fps friction
|
||||||
// float friction = water ? 2.0f : 6.0f,
|
// float friction = water ? 2.0f : 6.0f,
|
||||||
// fpsfric = friction/curtime*20.0f,
|
// fpsfric = friction/curtime*20.0f,
|
||||||
// c = water ? 1.0f : clamp((pl->floor.z - SLOPEZ)/(FLOORZ-SLOPEZ), 0.0f, 1.0f);
|
// c = water ? 1.0f : std::clamp((pl->floor.z - SLOPEZ)/(FLOORZ-SLOPEZ), 0.0f, 1.0f);
|
||||||
// pl->falling.mul(1 - c/fpsfric);
|
// pl->falling.mul(1 - c/fpsfric);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1889,7 +1891,7 @@ bool moveplayer(physent *pl, int moveres, bool local, int curtime)
|
||||||
|
|
||||||
// automatically apply smooth roll when strafing
|
// automatically apply smooth roll when strafing
|
||||||
|
|
||||||
if(pl->strafe && maxroll) pl->roll = clamp(pl->roll - pow(clamp(1.0f + pl->strafe*pl->roll/maxroll, 0.0f, 1.0f), 0.33f)*pl->strafe*curtime*straferoll, -maxroll, maxroll);
|
if(pl->strafe && maxroll) pl->roll = std::clamp(pl->roll - pow(std::clamp(1.0f + pl->strafe*pl->roll/maxroll, 0.0f, 1.0f), 0.33f)*pl->strafe*curtime*straferoll, float(-maxroll), float(maxroll));
|
||||||
else pl->roll *= curtime == PHYSFRAMETIME ? faderoll : pow(faderoll, curtime/float(PHYSFRAMETIME));
|
else pl->roll *= curtime == PHYSFRAMETIME ? faderoll : pow(faderoll, curtime/float(PHYSFRAMETIME));
|
||||||
|
|
||||||
// play sounds on water transitions
|
// play sounds on water transitions
|
||||||
|
@ -1916,7 +1918,7 @@ void physicsframe() // optimally schedule physics frames inside the gra
|
||||||
if(diff <= 0) physsteps = 0;
|
if(diff <= 0) physsteps = 0;
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
physframetime = clamp(game::scaletime(PHYSFRAMETIME)/100, 1, PHYSFRAMETIME);
|
physframetime = std::clamp(game::scaletime(PHYSFRAMETIME)/100, 1, PHYSFRAMETIME);
|
||||||
physsteps = (diff + physframetime - 1)/physframetime;
|
physsteps = (diff + physframetime - 1)/physframetime;
|
||||||
lastphysframe += physsteps * physframetime;
|
lastphysframe += physsteps * physframetime;
|
||||||
}
|
}
|
||||||
|
|
|
@ -4,6 +4,8 @@
|
||||||
|
|
||||||
#include <ctime>
|
#include <ctime>
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
#include <shared/glemu.hh>
|
#include <shared/glemu.hh>
|
||||||
#include <shared/igame.hh>
|
#include <shared/igame.hh>
|
||||||
|
@ -1474,14 +1476,14 @@ void recomputecamera()
|
||||||
if(game::collidecamera())
|
if(game::collidecamera())
|
||||||
{
|
{
|
||||||
movecamera(camera1, dir, thirdpersondistance, 1);
|
movecamera(camera1, dir, thirdpersondistance, 1);
|
||||||
movecamera(camera1, dir, clamp(thirdpersondistance - camera1->o.dist(player->o), 0.0f, 1.0f), 0.1f);
|
movecamera(camera1, dir, std::clamp(thirdpersondistance - camera1->o.dist(player->o), 0.0f, 1.0f), 0.1f);
|
||||||
if(thirdpersonup)
|
if(thirdpersonup)
|
||||||
{
|
{
|
||||||
vec pos = camera1->o;
|
vec pos = camera1->o;
|
||||||
float dist = fabs(thirdpersonup);
|
float dist = fabs(thirdpersonup);
|
||||||
if(thirdpersonup < 0) up.neg();
|
if(thirdpersonup < 0) up.neg();
|
||||||
movecamera(camera1, up, dist, 1);
|
movecamera(camera1, up, dist, 1);
|
||||||
movecamera(camera1, up, clamp(dist - camera1->o.dist(pos), 0.0f, 1.0f), 0.1f);
|
movecamera(camera1, up, std::clamp(dist - camera1->o.dist(pos), 0.0f, 1.0f), 0.1f);
|
||||||
}
|
}
|
||||||
if(thirdpersonside)
|
if(thirdpersonside)
|
||||||
{
|
{
|
||||||
|
@ -1489,7 +1491,7 @@ void recomputecamera()
|
||||||
float dist = fabs(thirdpersonside);
|
float dist = fabs(thirdpersonside);
|
||||||
if(thirdpersonside < 0) side.neg();
|
if(thirdpersonside < 0) side.neg();
|
||||||
movecamera(camera1, side, dist, 1);
|
movecamera(camera1, side, dist, 1);
|
||||||
movecamera(camera1, side, clamp(dist - camera1->o.dist(pos), 0.0f, 1.0f), 0.1f);
|
movecamera(camera1, side, std::clamp(dist - camera1->o.dist(pos), 0.0f, 1.0f), 0.1f);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
|
@ -1904,7 +1906,7 @@ static void blendfog(int fogmat, float below, float blend, float logblend, float
|
||||||
{
|
{
|
||||||
const bvec &wcol = getwatercolour(fogmat), &wdeepcol = getwaterdeepcolour(fogmat);
|
const bvec &wcol = getwatercolour(fogmat), &wdeepcol = getwaterdeepcolour(fogmat);
|
||||||
int wfog = getwaterfog(fogmat), wdeep = getwaterdeep(fogmat);
|
int wfog = getwaterfog(fogmat), wdeep = getwaterdeep(fogmat);
|
||||||
float deepfade = clamp(below/max(wdeep, wfog), 0.0f, 1.0f);
|
float deepfade = std::clamp(below/max(wdeep, wfog), 0.0f, 1.0f);
|
||||||
vec color;
|
vec color;
|
||||||
color.lerp(wcol.tocolor(), wdeepcol.tocolor(), deepfade);
|
color.lerp(wcol.tocolor(), wdeepcol.tocolor(), deepfade);
|
||||||
fogc.add(vec(color).mul(blend));
|
fogc.add(vec(color).mul(blend));
|
||||||
|
@ -1985,7 +1987,7 @@ static void blendfogoverlay(int fogmat, float below, float blend, vec &overlay)
|
||||||
{
|
{
|
||||||
const bvec &wcol = getwatercolour(fogmat), &wdeepcol = getwaterdeepcolour(fogmat);
|
const bvec &wcol = getwatercolour(fogmat), &wdeepcol = getwaterdeepcolour(fogmat);
|
||||||
int wfog = getwaterfog(fogmat), wdeep = getwaterdeep(fogmat);
|
int wfog = getwaterfog(fogmat), wdeep = getwaterdeep(fogmat);
|
||||||
float deepfade = clamp(below/max(wdeep, wfog), 0.0f, 1.0f);
|
float deepfade = std::clamp(below/max(wdeep, wfog), 0.0f, 1.0f);
|
||||||
vec color = vec(wcol.r, wcol.g, wcol.b).lerp(vec(wdeepcol.r, wdeepcol.g, wdeepcol.b), deepfade);
|
vec color = vec(wcol.r, wcol.g, wcol.b).lerp(vec(wdeepcol.r, wdeepcol.g, wdeepcol.b), deepfade);
|
||||||
overlay.add(color.div(min(32.0f + max(color.r, max(color.g, color.b))*7.0f/8.0f, 255.0f)).max(0.4f).mul(blend));
|
overlay.add(color.div(min(32.0f + max(color.r, max(color.g, color.b))*7.0f/8.0f, 255.0f)).max(0.4f).mul(blend));
|
||||||
break;
|
break;
|
||||||
|
@ -2262,7 +2264,7 @@ void drawcubemap(int size, const vec &o, float yaw, float pitch, const cubemapsi
|
||||||
|
|
||||||
renderwaterfog(fogmat, fogbelow);
|
renderwaterfog(fogmat, fogbelow);
|
||||||
|
|
||||||
setfog(fogmat, fogbelow, clamp(fogbelow, 0.0f, 1.0f), abovemat);
|
setfog(fogmat, fogbelow, std::clamp(fogbelow, 0.0f, 1.0f), abovemat);
|
||||||
}
|
}
|
||||||
|
|
||||||
rendertransparent();
|
rendertransparent();
|
||||||
|
@ -2458,7 +2460,7 @@ void gl_drawview()
|
||||||
|
|
||||||
renderwaterfog(fogmat, fogbelow);
|
renderwaterfog(fogmat, fogbelow);
|
||||||
|
|
||||||
setfog(fogmat, fogbelow, clamp(fogbelow, 0.0f, 1.0f), abovemat);
|
setfog(fogmat, fogbelow, std::clamp(fogbelow, 0.0f, 1.0f), abovemat);
|
||||||
}
|
}
|
||||||
|
|
||||||
rendertransparent();
|
rendertransparent();
|
||||||
|
@ -2492,7 +2494,7 @@ void gl_drawview()
|
||||||
glDisable(GL_CULL_FACE);
|
glDisable(GL_CULL_FACE);
|
||||||
glDisable(GL_DEPTH_TEST);
|
glDisable(GL_DEPTH_TEST);
|
||||||
|
|
||||||
if(fogoverlay && fogmat != MAT_AIR) drawfogoverlay(fogmat, fogbelow, clamp(fogbelow, 0.0f, 1.0f), abovemat);
|
if(fogoverlay && fogmat != MAT_AIR) drawfogoverlay(fogmat, fogbelow, std::clamp(fogbelow, 0.0f, 1.0f), abovemat);
|
||||||
|
|
||||||
doaa(setuppostfx(vieww, viewh, scalefbo), processhdr);
|
doaa(setuppostfx(vieww, viewh, scalefbo), processhdr);
|
||||||
renderpostfx(scalefbo);
|
renderpostfx(scalefbo);
|
||||||
|
|
|
@ -2,6 +2,8 @@
|
||||||
|
|
||||||
#include <climits>
|
#include <climits>
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
#include <shared/glemu.hh>
|
#include <shared/glemu.hh>
|
||||||
#include <shared/igame.hh>
|
#include <shared/igame.hh>
|
||||||
|
@ -1604,7 +1606,7 @@ struct lightinfo
|
||||||
if(e.attached && e.attached->type == ET_SPOTLIGHT)
|
if(e.attached && e.attached->type == ET_SPOTLIGHT)
|
||||||
{
|
{
|
||||||
dir = vec(e.attached->o).sub(e.o).normalize();
|
dir = vec(e.attached->o).sub(e.o).normalize();
|
||||||
spot = clamp(int(e.attached->attr1), 1, 89);
|
spot = std::clamp(int(e.attached->attr1), 1, 89);
|
||||||
calcspot();
|
calcspot();
|
||||||
}
|
}
|
||||||
calcscissor();
|
calcscissor();
|
||||||
|
@ -3555,8 +3557,8 @@ void collectlights()
|
||||||
int w, h;
|
int w, h;
|
||||||
if(l.spot) { w = 1; h = 1; prec *= tan360(l.spot); lod = smspotprec; }
|
if(l.spot) { w = 1; h = 1; prec *= tan360(l.spot); lod = smspotprec; }
|
||||||
else { w = 3; h = 2; lod = smcubeprec; }
|
else { w = 3; h = 2; lod = smcubeprec; }
|
||||||
lod *= clamp(l.radius * prec / sqrtf(max(1.0f, l.dist/l.radius)), float(smminsize), float(smmaxsize));
|
lod *= std::clamp(l.radius * prec / sqrtf(max(1.0f, l.dist/l.radius)), float(smminsize), float(smmaxsize));
|
||||||
int size = clamp(int(ceil((lod * shadowatlaspacker.w) / SHADOWATLAS_SIZE)), 1, shadowatlaspacker.w / w);
|
int size = std::clamp(int(ceil((lod * shadowatlaspacker.w) / SHADOWATLAS_SIZE)), 1, shadowatlaspacker.w / w);
|
||||||
w *= size;
|
w *= size;
|
||||||
h *= size;
|
h *= size;
|
||||||
|
|
||||||
|
@ -3743,8 +3745,8 @@ void packlights()
|
||||||
int w, h;
|
int w, h;
|
||||||
if(l.spot) { w = 1; h = 1; prec *= tan360(l.spot); lod = smspotprec; }
|
if(l.spot) { w = 1; h = 1; prec *= tan360(l.spot); lod = smspotprec; }
|
||||||
else { w = 3; h = 2; lod = smcubeprec; }
|
else { w = 3; h = 2; lod = smcubeprec; }
|
||||||
lod *= clamp(l.radius * prec / sqrtf(max(1.0f, l.dist/l.radius)), float(smminsize), float(smmaxsize));
|
lod *= std::clamp(l.radius * prec / sqrtf(max(1.0f, l.dist/l.radius)), float(smminsize), float(smmaxsize));
|
||||||
int size = clamp(int(ceil((lod * shadowatlaspacker.w) / SHADOWATLAS_SIZE)), 1, shadowatlaspacker.w / w);
|
int size = std::clamp(int(ceil((lod * shadowatlaspacker.w) / SHADOWATLAS_SIZE)), 1, shadowatlaspacker.w / w);
|
||||||
w *= size;
|
w *= size;
|
||||||
h *= size;
|
h *= size;
|
||||||
ushort x = USHRT_MAX, y = USHRT_MAX;
|
ushort x = USHRT_MAX, y = USHRT_MAX;
|
||||||
|
@ -4330,7 +4332,7 @@ int calcshadowinfo(const extentity &e, vec &origin, float &radius, vec &spotloc,
|
||||||
border = 0;
|
border = 0;
|
||||||
lod = smspotprec;
|
lod = smspotprec;
|
||||||
spotloc = e.attached->o;
|
spotloc = e.attached->o;
|
||||||
spotangle = clamp(int(e.attached->attr1), 1, 89);
|
spotangle = std::clamp(int(e.attached->attr1), 1, 89);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -4343,7 +4345,7 @@ int calcshadowinfo(const extentity &e, vec &origin, float &radius, vec &spotloc,
|
||||||
}
|
}
|
||||||
|
|
||||||
lod *= smminsize;
|
lod *= smminsize;
|
||||||
int size = clamp(int(ceil((lod * shadowatlaspacker.w) / SHADOWATLAS_SIZE)), 1, shadowatlaspacker.w / w);
|
int size = std::clamp(int(ceil((lod * shadowatlaspacker.w) / SHADOWATLAS_SIZE)), 1, shadowatlaspacker.w / w);
|
||||||
bias = border / float(size - border);
|
bias = border / float(size - border);
|
||||||
|
|
||||||
return type;
|
return type;
|
||||||
|
@ -4936,8 +4938,8 @@ void shademodelpreview(int x, int y, int w, int h, bool background, bool scissor
|
||||||
|
|
||||||
if(scissor) glEnable(GL_SCISSOR_TEST);
|
if(scissor) glEnable(GL_SCISSOR_TEST);
|
||||||
|
|
||||||
int sx = clamp(x, 0, hudw), sy = clamp(y, 0, hudh),
|
int sx = std::clamp(x, 0, hudw), sy = std::clamp(y, 0, hudh),
|
||||||
sw = clamp(x + w, 0, hudw) - sx, sh = clamp(y + h, 0, hudh) - sy;
|
sw = std::clamp(x + w, 0, hudw) - sx, sh = std::clamp(y + h, 0, hudh) - sy;
|
||||||
float sxk = 2.0f/hudw, syk = 2.0f/hudh, txk = vieww/float(w), tyk = viewh/float(h);
|
float sxk = 2.0f/hudw, syk = 2.0f/hudh, txk = vieww/float(w), tyk = viewh/float(h);
|
||||||
hudquad(sx*sxk - 1, sy*syk - 1, sw*sxk, sh*syk, (sx-x)*txk, (sy-y)*tyk, sw*txk, sh*tyk);
|
hudquad(sx*sxk - 1, sy*syk - 1, sw*sxk, sh*syk, (sx-x)*txk, (sy-y)*tyk, sw*txk, sh*tyk);
|
||||||
|
|
||||||
|
|
|
@ -3,6 +3,7 @@
|
||||||
#include <climits>
|
#include <climits>
|
||||||
|
|
||||||
#include <new>
|
#include <new>
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <sauerlib/encoding.hh>
|
#include <sauerlib/encoding.hh>
|
||||||
|
|
||||||
|
@ -116,14 +117,14 @@ COMMAND(mdlspec, "f");
|
||||||
static void mdlgloss(int *gloss)
|
static void mdlgloss(int *gloss)
|
||||||
{
|
{
|
||||||
checkmdl;
|
checkmdl;
|
||||||
loadingmodel->setgloss(clamp(*gloss, 0, 2));
|
loadingmodel->setgloss(std::clamp(*gloss, 0, 2));
|
||||||
}
|
}
|
||||||
COMMAND(mdlgloss, "i");
|
COMMAND(mdlgloss, "i");
|
||||||
|
|
||||||
static void mdlalphatest(float *cutoff)
|
static void mdlalphatest(float *cutoff)
|
||||||
{
|
{
|
||||||
checkmdl;
|
checkmdl;
|
||||||
loadingmodel->setalphatest(max(0.0f, min(1.0f, *cutoff)));
|
loadingmodel->setalphatest(std::max(0.0f, std::min(1.0f, *cutoff)));
|
||||||
}
|
}
|
||||||
COMMAND(mdlalphatest, "f");
|
COMMAND(mdlalphatest, "f");
|
||||||
|
|
||||||
|
@ -305,7 +306,7 @@ static void rdlimitdist(int *v1, int *v2, float *mindist, float *maxdist)
|
||||||
d.vert[0] = *v1;
|
d.vert[0] = *v1;
|
||||||
d.vert[1] = *v2;
|
d.vert[1] = *v2;
|
||||||
d.mindist = *mindist;
|
d.mindist = *mindist;
|
||||||
d.maxdist = max(*maxdist, *mindist);
|
d.maxdist = std::max(*maxdist, *mindist);
|
||||||
}
|
}
|
||||||
COMMAND(rdlimitdist, "iiff");
|
COMMAND(rdlimitdist, "iiff");
|
||||||
|
|
||||||
|
@ -345,7 +346,7 @@ static void mapmodel(char *name)
|
||||||
static void mapmodelreset(int *n)
|
static void mapmodelreset(int *n)
|
||||||
{
|
{
|
||||||
if(!(identflags&IDF_OVERRIDDEN) && !game::allowedittoggle()) return;
|
if(!(identflags&IDF_OVERRIDDEN) && !game::allowedittoggle()) return;
|
||||||
mapmodels.shrink(clamp(*n, 0, mapmodels.length()));
|
mapmodels.shrink(std::clamp(*n, 0, mapmodels.length()));
|
||||||
}
|
}
|
||||||
|
|
||||||
const char *mapmodelname(int i) { return mapmodels.inrange(i) ? mapmodels[i].name : nullptr; }
|
const char *mapmodelname(int i) { return mapmodels.inrange(i) ? mapmodels[i].name : nullptr; }
|
||||||
|
@ -766,10 +767,10 @@ void rendermodelbatches()
|
||||||
ivec bbmin(vec(bm.center).sub(bm.radius)), bbmax(vec(bm.center).add(bm.radius+1));
|
ivec bbmin(vec(bm.center).sub(bm.radius)), bbmax(vec(bm.center).add(bm.radius+1));
|
||||||
if(calcbbscissor(bbmin, bbmax, sx1, sy1, sx2, sy2))
|
if(calcbbscissor(bbmin, bbmax, sx1, sy1, sx2, sy2))
|
||||||
{
|
{
|
||||||
transmdlsx1 = min(transmdlsx1, sx1);
|
transmdlsx1 = std::min(transmdlsx1, sx1);
|
||||||
transmdlsy1 = min(transmdlsy1, sy1);
|
transmdlsy1 = std::min(transmdlsy1, sy1);
|
||||||
transmdlsx2 = max(transmdlsx2, sx2);
|
transmdlsx2 = std::max(transmdlsx2, sx2);
|
||||||
transmdlsy2 = max(transmdlsy2, sy2);
|
transmdlsy2 = std::max(transmdlsy2, sy2);
|
||||||
masktiles(transmdltiles, sx1, sy1, sx2, sy2);
|
masktiles(transmdltiles, sx1, sy1, sx2, sy2);
|
||||||
}
|
}
|
||||||
continue;
|
continue;
|
||||||
|
@ -976,7 +977,7 @@ void rendermodel(const char *mdl, int anim, const vec &o, float yaw, float pitch
|
||||||
{
|
{
|
||||||
if(anim&ANIM_RAGDOLL && d->ragdoll->millis >= basetime)
|
if(anim&ANIM_RAGDOLL && d->ragdoll->millis >= basetime)
|
||||||
{
|
{
|
||||||
radius = max(radius, d->ragdoll->radius);
|
radius = std::max(radius, d->ragdoll->radius);
|
||||||
center = d->ragdoll->center;
|
center = d->ragdoll->center;
|
||||||
goto hasboundbox;
|
goto hasboundbox;
|
||||||
}
|
}
|
||||||
|
@ -1144,7 +1145,7 @@ void setbbfrommodel(dynent *d, const char *mdl)
|
||||||
if(m->collide != COLLIDE_ELLIPSE) d->collidetype = COLLIDE_OBB;
|
if(m->collide != COLLIDE_ELLIPSE) d->collidetype = COLLIDE_OBB;
|
||||||
d->xradius = radius.x + fabs(center.x);
|
d->xradius = radius.x + fabs(center.x);
|
||||||
d->yradius = radius.y + fabs(center.y);
|
d->yradius = radius.y + fabs(center.y);
|
||||||
d->radius = d->collidetype==COLLIDE_OBB ? sqrtf(d->xradius*d->xradius + d->yradius*d->yradius) : max(d->xradius, d->yradius);
|
d->radius = d->collidetype==COLLIDE_OBB ? sqrtf(d->xradius*d->xradius + d->yradius*d->yradius) : std::max(d->xradius, d->yradius);
|
||||||
d->eyeheight = (center.z-radius.z) + radius.z*2*m->eyeheight;
|
d->eyeheight = (center.z-radius.z) + radius.z*2*m->eyeheight;
|
||||||
d->aboveeye = radius.z*2*(1.0f-m->eyeheight);
|
d->aboveeye = radius.z*2*(1.0f-m->eyeheight);
|
||||||
if (d->aboveeye + d->eyeheight <= 0.5f)
|
if (d->aboveeye + d->eyeheight <= 0.5f)
|
||||||
|
|
|
@ -1,5 +1,9 @@
|
||||||
// renderparticles.cpp
|
// renderparticles.cpp
|
||||||
|
|
||||||
|
#include "renderparticles.hh"
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
#include <shared/glemu.hh>
|
#include <shared/glemu.hh>
|
||||||
#include <shared/igame.hh>
|
#include <shared/igame.hh>
|
||||||
|
@ -1137,7 +1141,7 @@ void particle_trail(int type, int fade, const vec &s, const vec &e, int color, f
|
||||||
if(!canaddparticles()) return;
|
if(!canaddparticles()) return;
|
||||||
vec v;
|
vec v;
|
||||||
float d = e.dist(s, v);
|
float d = e.dist(s, v);
|
||||||
int steps = clamp(int(d*2), 1, maxtrail);
|
int steps = std::clamp(int(d*2), 1, maxtrail);
|
||||||
v.div(steps);
|
v.div(steps);
|
||||||
vec p = s;
|
vec p = s;
|
||||||
loopi(steps)
|
loopi(steps)
|
||||||
|
@ -1170,7 +1174,7 @@ void particle_meter(const vec &s, float val, int type, int fade, int color, int
|
||||||
p->color2[0] = color2>>16;
|
p->color2[0] = color2>>16;
|
||||||
p->color2[1] = (color2>>8)&0xFF;
|
p->color2[1] = (color2>>8)&0xFF;
|
||||||
p->color2[2] = color2&0xFF;
|
p->color2[2] = color2&0xFF;
|
||||||
p->progress = clamp(int(val*100), 0, 100);
|
p->progress = std::clamp(int(val*100), 0, 100);
|
||||||
}
|
}
|
||||||
|
|
||||||
void particle_flare(const vec &p, const vec &dest, int fade, int type, int color, float size, physent *owner)
|
void particle_flare(const vec &p, const vec &dest, int fade, int type, int color, float size, physent *owner)
|
||||||
|
@ -1277,7 +1281,7 @@ static void regularshape(int type, int radius, int color, int dir, int num, int
|
||||||
|
|
||||||
if(taper)
|
if(taper)
|
||||||
{
|
{
|
||||||
float dist = clamp(from.dist2(camera1->o)/maxparticledistance, 0.0f, 1.0f);
|
float dist = std::clamp(from.dist2(camera1->o)/maxparticledistance, 0.0f, 1.0f);
|
||||||
if(dist > 0.2f)
|
if(dist > 0.2f)
|
||||||
{
|
{
|
||||||
dist = 1 - (dist - 0.2f)/0.8f;
|
dist = 1 - (dist - 0.2f)/0.8f;
|
||||||
|
@ -1341,7 +1345,7 @@ static void makeparticles(entity &e)
|
||||||
if(e.attr3 > 0) color = colorfromattr(e.attr3);
|
if(e.attr3 > 0) color = colorfromattr(e.attr3);
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
int mat = MAT_WATER + clamp(-e.attr3, 0, 3);
|
int mat = MAT_WATER + std::clamp(-e.attr3, 0, 3);
|
||||||
color = getwaterfallcolour(mat).tohexcolor();
|
color = getwaterfallcolour(mat).tohexcolor();
|
||||||
if(!color) color = getwatercolour(mat).tohexcolor();
|
if(!color) color = getwatercolour(mat).tohexcolor();
|
||||||
}
|
}
|
||||||
|
@ -1375,7 +1379,7 @@ static void makeparticles(entity &e)
|
||||||
p->color2[0] = color2>>16;
|
p->color2[0] = color2>>16;
|
||||||
p->color2[1] = (color2>>8)&0xFF;
|
p->color2[1] = (color2>>8)&0xFF;
|
||||||
p->color2[2] = color2&0xFF;
|
p->color2[2] = color2&0xFF;
|
||||||
p->progress = clamp(int(e.attr2), 0, 100);
|
p->progress = std::clamp(int(e.attr2), 0, 100);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case 11: // flame <radius> <height> <rgb> - radius=100, height=100 is the classic size
|
case 11: // flame <radius> <height> <rgb> - radius=100, height=100 is the classic size
|
||||||
|
|
|
@ -4,6 +4,8 @@
|
||||||
|
|
||||||
#include <climits>
|
#include <climits>
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
#include <shared/glemu.hh>
|
#include <shared/glemu.hh>
|
||||||
#include <shared/igame.hh>
|
#include <shared/igame.hh>
|
||||||
|
@ -139,7 +141,7 @@ static inline void addvisibleva(vtxarray *va)
|
||||||
float dist = vadist(va, camera1->o);
|
float dist = vadist(va, camera1->o);
|
||||||
va->distance = int(dist); /*cv.dist(camera1->o) - va->size*SQRT3/2*/
|
va->distance = int(dist); /*cv.dist(camera1->o) - va->size*SQRT3/2*/
|
||||||
|
|
||||||
int hash = clamp(int(dist*VASORTSIZE/worldsize), 0, VASORTSIZE-1);
|
int hash = std::clamp(int(dist*VASORTSIZE/worldsize), 0, VASORTSIZE-1);
|
||||||
vtxarray **prev = &vasort[hash], *cur = vasort[hash];
|
vtxarray **prev = &vasort[hash], *cur = vasort[hash];
|
||||||
|
|
||||||
while(cur && va->distance >= cur->distance)
|
while(cur && va->distance >= cur->distance)
|
||||||
|
@ -913,7 +915,7 @@ static inline void addshadowva(vtxarray *va, float dist)
|
||||||
{
|
{
|
||||||
va->rdistance = int(dist);
|
va->rdistance = int(dist);
|
||||||
|
|
||||||
int hash = clamp(int(dist*VASORTSIZE/shadowradius), 0, VASORTSIZE-1);
|
int hash = std::clamp(int(dist*VASORTSIZE/shadowradius), 0, VASORTSIZE-1);
|
||||||
vtxarray **prev = &vasort[hash], *cur = vasort[hash];
|
vtxarray **prev = &vasort[hash], *cur = vasort[hash];
|
||||||
|
|
||||||
while(cur && va->rdistance > cur->rdistance)
|
while(cur && va->rdistance > cur->rdistance)
|
||||||
|
@ -2724,7 +2726,7 @@ shadowmesh *findshadowmesh(int idx, extentity &e)
|
||||||
switch(m->type)
|
switch(m->type)
|
||||||
{
|
{
|
||||||
case SM_SPOT:
|
case SM_SPOT:
|
||||||
if(!e.attached || e.attached->type != ET_SPOTLIGHT || m->spotloc != e.attached->o || m->spotangle < clamp(int(e.attached->attr1), 1, 89))
|
if(!e.attached || e.attached->type != ET_SPOTLIGHT || m->spotloc != e.attached->o || m->spotangle < std::clamp(int(e.attached->attr1), 1, 89))
|
||||||
return nullptr;
|
return nullptr;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
|
@ -4,6 +4,8 @@
|
||||||
|
|
||||||
#include <climits>
|
#include <climits>
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <sauerlib/encoding.hh>
|
#include <sauerlib/encoding.hh>
|
||||||
|
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
|
@ -586,7 +588,7 @@ static void allocglslactiveuniforms(Shader &s)
|
||||||
name[0] = '\0';
|
name[0] = '\0';
|
||||||
glGetActiveUniform_(s.program, i, sizeof(name)-1, &namelen, &size, &format, name);
|
glGetActiveUniform_(s.program, i, sizeof(name)-1, &namelen, &size, &format, name);
|
||||||
if(namelen <= 0 || size <= 0) continue;
|
if(namelen <= 0 || size <= 0) continue;
|
||||||
name[clamp(int(namelen), 0, (int)sizeof(name)-2)] = '\0';
|
name[std::clamp(int(namelen), 0, (int)sizeof(name)-2)] = '\0';
|
||||||
char *brak = strchr(name, '[');
|
char *brak = strchr(name, '[');
|
||||||
if(brak) *brak = '\0';
|
if(brak) *brak = '\0';
|
||||||
setglsluniformformat(s, name, format, size);
|
setglsluniformformat(s, name, format, size);
|
||||||
|
@ -1521,7 +1523,7 @@ ICOMMAND(addpostfx, "siisffff", (char *name, int *bind, int *scale, char *inputs
|
||||||
}
|
}
|
||||||
inputmask &= (1<<NUMPOSTFXBINDS)-1;
|
inputmask &= (1<<NUMPOSTFXBINDS)-1;
|
||||||
freemask &= (1<<NUMPOSTFXBINDS)-1;
|
freemask &= (1<<NUMPOSTFXBINDS)-1;
|
||||||
addpostfx(name, clamp(*bind, 0, NUMPOSTFXBINDS-1), max(*scale, 0), inputmask, freemask, vec4(*x, *y, *z, *w));
|
addpostfx(name, std::clamp(*bind, 0, NUMPOSTFXBINDS-1), max(*scale, 0), inputmask, freemask, vec4(*x, *y, *z, *w));
|
||||||
});
|
});
|
||||||
|
|
||||||
ICOMMAND(setpostfx, "sffff", (char *name, float *x, float *y, float *z, float *w),
|
ICOMMAND(setpostfx, "sffff", (char *name, float *x, float *y, float *z, float *w),
|
||||||
|
|
|
@ -779,7 +779,7 @@ struct skelmodel : animmodel
|
||||||
vec forward1 = pose1.transformnormal(forward).project(axis).normalize(),
|
vec forward1 = pose1.transformnormal(forward).project(axis).normalize(),
|
||||||
forward2 = pose2.transformnormal(forward).project(axis).normalize(),
|
forward2 = pose2.transformnormal(forward).project(axis).normalize(),
|
||||||
daxis = vec().cross(forward1, forward2);
|
daxis = vec().cross(forward1, forward2);
|
||||||
float dx = clamp(forward1.dot(forward2), -1.0f, 1.0f), dy = clamp(daxis.magnitude(), -1.0f, 1.0f);
|
float dx = std::clamp(forward1.dot(forward2), -1.0f, 1.0f), dy = std::clamp(daxis.magnitude(), -1.0f, 1.0f);
|
||||||
if(daxis.dot(axis) < 0) dy = -dy;
|
if(daxis.dot(axis) < 0) dy = -dy;
|
||||||
return atan2f(dy, dx)/RAD;
|
return atan2f(dy, dx)/RAD;
|
||||||
}
|
}
|
||||||
|
@ -802,7 +802,7 @@ struct skelmodel : animmodel
|
||||||
float tpitch = pitch - t.deviated;
|
float tpitch = pitch - t.deviated;
|
||||||
for(int parent = t.corrects; parent >= 0; parent = pitchcorrects[parent].parent)
|
for(int parent = t.corrects; parent >= 0; parent = pitchcorrects[parent].parent)
|
||||||
tpitch -= pitchcorrects[parent].pitchangle;
|
tpitch -= pitchcorrects[parent].pitchangle;
|
||||||
if(t.pitchmin || t.pitchmax) tpitch = clamp(tpitch, t.pitchmin, t.pitchmax);
|
if(t.pitchmin || t.pitchmax) tpitch = std::clamp(tpitch, t.pitchmin, t.pitchmax);
|
||||||
loopv(pitchcorrects)
|
loopv(pitchcorrects)
|
||||||
{
|
{
|
||||||
pitchcorrect &c = pitchcorrects[i];
|
pitchcorrect &c = pitchcorrects[i];
|
||||||
|
@ -812,11 +812,11 @@ struct skelmodel : animmodel
|
||||||
used = tpitch*c.pitchscale;
|
used = tpitch*c.pitchscale;
|
||||||
if(c.pitchmin || c.pitchmax)
|
if(c.pitchmin || c.pitchmax)
|
||||||
{
|
{
|
||||||
if(used < 0) used = clamp(c.pitchmin, used, 0.0f);
|
if(used < 0) used = std::clamp(c.pitchmin, used, 0.0f);
|
||||||
else used = clamp(c.pitchmax, 0.0f, used);
|
else used = std::clamp(c.pitchmax, 0.0f, used);
|
||||||
}
|
}
|
||||||
if(used < 0) used = clamp(avail, used, 0.0f);
|
if(used < 0) used = std::clamp(avail, used, 0.0f);
|
||||||
else used = clamp(avail, 0.0f, used);
|
else used = std::clamp(avail, 0.0f, used);
|
||||||
c.pitchangle = used;
|
c.pitchangle = used;
|
||||||
c.pitchtotal = used + total;
|
c.pitchtotal = used + total;
|
||||||
}
|
}
|
||||||
|
@ -871,7 +871,7 @@ struct skelmodel : animmodel
|
||||||
else sc.bdata[b.interpindex].mul(sc.bdata[b.interpparent], d);
|
else sc.bdata[b.interpindex].mul(sc.bdata[b.interpparent], d);
|
||||||
|
|
||||||
float angle;
|
float angle;
|
||||||
if(b.pitchscale) { angle = b.pitchscale*pitch + b.pitchoffset; if(b.pitchmin || b.pitchmax) angle = clamp(angle, b.pitchmin, b.pitchmax); }
|
if(b.pitchscale) { angle = b.pitchscale*pitch + b.pitchoffset; if(b.pitchmin || b.pitchmax) angle = std::clamp(angle, b.pitchmin, b.pitchmax); }
|
||||||
else if(b.correctindex >= 0) angle = pitchcorrects[b.correctindex].pitchangle;
|
else if(b.correctindex >= 0) angle = pitchcorrects[b.correctindex].pitchangle;
|
||||||
else continue;
|
else continue;
|
||||||
if(as->cur.anim&ANIM_NOPITCH || (as->interp < 1 && as->prev.anim&ANIM_NOPITCH))
|
if(as->cur.anim&ANIM_NOPITCH || (as->interp < 1 && as->prev.anim&ANIM_NOPITCH))
|
||||||
|
@ -1660,7 +1660,7 @@ template<class MDL> struct skelcommands : modelcommands<MDL, struct MDL::skelmes
|
||||||
if(!MDL::loading) { conoutf("not loading an %s", MDL::formatname()); return; }
|
if(!MDL::loading) { conoutf("not loading an %s", MDL::formatname()); return; }
|
||||||
defformatstring(filename, "%s/%s", MDL::dir, meshfile);
|
defformatstring(filename, "%s/%s", MDL::dir, meshfile);
|
||||||
part &mdl = MDL::loading->addpart();
|
part &mdl = MDL::loading->addpart();
|
||||||
mdl.meshes = MDL::loading->sharemeshes(path(filename), skelname[0] ? skelname : nullptr, *smooth > 0 ? cosf(clamp(*smooth, 0.0f, 180.0f)*RAD) : 2);
|
mdl.meshes = MDL::loading->sharemeshes(path(filename), skelname[0] ? skelname : nullptr, *smooth > 0 ? cosf(std::clamp(*smooth, 0.0f, 180.0f)*RAD) : 2);
|
||||||
if(!mdl.meshes) conoutf("could not load %s", filename);
|
if(!mdl.meshes) conoutf("could not load %s", filename);
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
|
@ -1749,7 +1749,7 @@ template<class MDL> struct skelcommands : modelcommands<MDL, struct MDL::skelmes
|
||||||
loopv(skel->pitchtargets) if(skel->pitchtargets[i].bone == bone) return;
|
loopv(skel->pitchtargets) if(skel->pitchtargets[i].bone == bone) return;
|
||||||
pitchtarget &t = skel->pitchtargets.add();
|
pitchtarget &t = skel->pitchtargets.add();
|
||||||
t.bone = bone;
|
t.bone = bone;
|
||||||
t.frame = sa->frame + clamp(*frameoffset, 0, sa->range-1);
|
t.frame = sa->frame + std::clamp(*frameoffset, 0, sa->range-1);
|
||||||
t.pitchmin = *pitchmin;
|
t.pitchmin = *pitchmin;
|
||||||
t.pitchmax = *pitchmax;
|
t.pitchmax = *pitchmax;
|
||||||
}
|
}
|
||||||
|
|
|
@ -4,6 +4,8 @@
|
||||||
|
|
||||||
#include <ctime>
|
#include <ctime>
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <zlib.h>
|
#include <zlib.h>
|
||||||
|
|
||||||
#include <sauerlib/encoding.hh>
|
#include <sauerlib/encoding.hh>
|
||||||
|
@ -79,8 +81,8 @@ template<int BPP> static void scaletexture(uchar * RESTRICT src, uint sw, uint s
|
||||||
int over, under;
|
int over, under;
|
||||||
for(over = 0; (darea>>over) > sarea; over++);
|
for(over = 0; (darea>>over) > sarea; over++);
|
||||||
for(under = 0; (darea<<under) < sarea; under++);
|
for(under = 0; (darea<<under) < sarea; under++);
|
||||||
uint cscale = clamp(under, over - 12, 12),
|
uint cscale = std::clamp(under, over - 12, 12),
|
||||||
ascale = clamp(12 + under - over, 0, 24),
|
ascale = std::clamp(12 + under - over, 0, 24),
|
||||||
dscale = ascale + 12 - cscale,
|
dscale = ascale + 12 - cscale,
|
||||||
area = ((ullong)darea<<ascale)/sarea;
|
area = ((ullong)darea<<ascale)/sarea;
|
||||||
dw *= wfrac;
|
dw *= wfrac;
|
||||||
|
@ -518,8 +520,8 @@ static void texoffset(ImageData &s, int xoffset, int yoffset)
|
||||||
|
|
||||||
static void texcrop(ImageData &s, int x, int y, int w, int h)
|
static void texcrop(ImageData &s, int x, int y, int w, int h)
|
||||||
{
|
{
|
||||||
x = clamp(x, 0, s.w);
|
x = std::clamp(x, 0, s.w);
|
||||||
y = clamp(y, 0, s.h);
|
y = std::clamp(y, 0, s.h);
|
||||||
w = min(w < 0 ? s.w : w, s.w - x);
|
w = min(w < 0 ? s.w : w, s.w - x);
|
||||||
h = min(h < 0 ? s.h : h, s.h - y);
|
h = min(h < 0 ? s.h : h, s.h - y);
|
||||||
if(!w || !h) return;
|
if(!w || !h) return;
|
||||||
|
@ -540,7 +542,7 @@ static void texmad(ImageData &s, const vec &mul, const vec &add)
|
||||||
swizzleimage(s);
|
swizzleimage(s);
|
||||||
int maxk = min(int(s.bpp), 3);
|
int maxk = min(int(s.bpp), 3);
|
||||||
writetex(s,
|
writetex(s,
|
||||||
loopk(maxk) dst[k] = uchar(clamp(dst[k]*mul[k] + 255*add[k], 0.0f, 255.0f));
|
loopk(maxk) dst[k] = uchar(std::clamp(dst[k]*mul[k] + 255*add[k], 0.0f, 255.0f));
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -550,7 +552,7 @@ static void texcolorify(ImageData &s, const vec &color, vec weights)
|
||||||
if(weights.iszero()) weights = vec(0.21f, 0.72f, 0.07f);
|
if(weights.iszero()) weights = vec(0.21f, 0.72f, 0.07f);
|
||||||
writetex(s,
|
writetex(s,
|
||||||
float lum = dst[0]*weights.x + dst[1]*weights.y + dst[2]*weights.z;
|
float lum = dst[0]*weights.x + dst[1]*weights.y + dst[2]*weights.z;
|
||||||
loopk(3) dst[k] = uchar(clamp(lum*color[k], 0.0f, 255.0f));
|
loopk(3) dst[k] = uchar(std::clamp(lum*color[k], 0.0f, 255.0f));
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -561,7 +563,7 @@ static void texcolormask(ImageData &s, const vec &color1, const vec &color2)
|
||||||
readwritetex(d, s,
|
readwritetex(d, s,
|
||||||
vec color;
|
vec color;
|
||||||
color.lerp(color2, color1, src[3]/255.0f);
|
color.lerp(color2, color1, src[3]/255.0f);
|
||||||
loopk(3) dst[k] = uchar(clamp(color[k]*src[k], 0.0f, 255.0f));
|
loopk(3) dst[k] = uchar(std::clamp(color[k]*src[k], 0.0f, 255.0f));
|
||||||
);
|
);
|
||||||
s.replace(d);
|
s.replace(d);
|
||||||
}
|
}
|
||||||
|
@ -651,7 +653,7 @@ static void texagrad(ImageData &s, float x2, float y2, float x1, float y1)
|
||||||
float curx = minx;
|
float curx = minx;
|
||||||
for(uchar *dst = dstrow, *end = &dstrow[s.w*s.bpp]; dst < end; dst += s.bpp)
|
for(uchar *dst = dstrow, *end = &dstrow[s.w*s.bpp]; dst < end; dst += s.bpp)
|
||||||
{
|
{
|
||||||
dst[0] = uchar(dst[0]*clamp(curx, 0.0f, 1.0f)*clamp(cury, 0.0f, 1.0f));
|
dst[0] = uchar(dst[0]*std::clamp(curx, 0.0f, 1.0f)*std::clamp(cury, 0.0f, 1.0f));
|
||||||
curx += dx;
|
curx += dx;
|
||||||
}
|
}
|
||||||
cury += dy;
|
cury += dy;
|
||||||
|
@ -1437,7 +1439,7 @@ static void blurtexture(int w, int h, uchar *dst, const uchar *src, int margin)
|
||||||
|
|
||||||
static void blurtexture(int n, int bpp, int w, int h, uchar *dst, const uchar *src, int margin = 0)
|
static void blurtexture(int n, int bpp, int w, int h, uchar *dst, const uchar *src, int margin = 0)
|
||||||
{
|
{
|
||||||
switch((clamp(n, 1, 2)<<4) | bpp)
|
switch((std::clamp(n, 1, 2)<<4) | bpp)
|
||||||
{
|
{
|
||||||
case 0x13: blurtexture<1, 3, false>(w, h, dst, src, margin); break;
|
case 0x13: blurtexture<1, 3, false>(w, h, dst, src, margin); break;
|
||||||
case 0x23: blurtexture<2, 3, false>(w, h, dst, src, margin); break;
|
case 0x23: blurtexture<2, 3, false>(w, h, dst, src, margin); break;
|
||||||
|
@ -1449,7 +1451,7 @@ static void blurtexture(int n, int bpp, int w, int h, uchar *dst, const uchar *s
|
||||||
#if 0
|
#if 0
|
||||||
static void blurnormals(int n, int w, int h, bvec *dst, const bvec *src, int margin = 0)
|
static void blurnormals(int n, int w, int h, bvec *dst, const bvec *src, int margin = 0)
|
||||||
{
|
{
|
||||||
switch(clamp(n, 1, 2))
|
switch(std::clamp(n, 1, 2))
|
||||||
{
|
{
|
||||||
case 1: blurtexture<1, 3, true>(w, h, dst->v, src->v, margin); break;
|
case 1: blurtexture<1, 3, true>(w, h, dst->v, src->v, margin); break;
|
||||||
case 2: blurtexture<2, 3, true>(w, h, dst->v, src->v, margin); break;
|
case 2: blurtexture<2, 3, true>(w, h, dst->v, src->v, margin); break;
|
||||||
|
@ -1601,7 +1603,7 @@ static bool texturedata(ImageData &d, const char *tname, bool msg = true, int *c
|
||||||
else if(matchstring(cmd, len, "blur"))
|
else if(matchstring(cmd, len, "blur"))
|
||||||
{
|
{
|
||||||
int emphasis = atoi(arg[0]), repeat = atoi(arg[1]);
|
int emphasis = atoi(arg[0]), repeat = atoi(arg[1]);
|
||||||
texblur(d, emphasis > 0 ? clamp(emphasis, 1, 2) : 1, repeat > 0 ? repeat : 1);
|
texblur(d, emphasis > 0 ? std::clamp(emphasis, 1, 2) : 1, repeat > 0 ? repeat : 1);
|
||||||
}
|
}
|
||||||
else if(matchstring(cmd, len, "premul")) texpremul(d);
|
else if(matchstring(cmd, len, "premul")) texpremul(d);
|
||||||
else if(matchstring(cmd, len, "agrad")) texagrad(d, atof(arg[0]), atof(arg[1]), atof(arg[2]), atof(arg[3]));
|
else if(matchstring(cmd, len, "agrad")) texagrad(d, atof(arg[0]), atof(arg[1]), atof(arg[2]), atof(arg[3]));
|
||||||
|
@ -1715,7 +1717,7 @@ static void texturereset(int *n)
|
||||||
if(!(identflags&IDF_OVERRIDDEN) && !game::allowedittoggle()) return;
|
if(!(identflags&IDF_OVERRIDDEN) && !game::allowedittoggle()) return;
|
||||||
defslot = nullptr;
|
defslot = nullptr;
|
||||||
resetslotshader();
|
resetslotshader();
|
||||||
int limit = clamp(*n, 0, slots.length());
|
int limit = std::clamp(*n, 0, slots.length());
|
||||||
for(int i = limit; i < slots.length(); i++)
|
for(int i = limit; i < slots.length(); i++)
|
||||||
{
|
{
|
||||||
Slot *s = slots[i];
|
Slot *s = slots[i];
|
||||||
|
@ -1978,11 +1980,11 @@ static void mergevslot(VSlot &dst, const VSlot &src, int diff, Slot *slot = null
|
||||||
}
|
}
|
||||||
if(diff & (1<<VSLOT_SCALE))
|
if(diff & (1<<VSLOT_SCALE))
|
||||||
{
|
{
|
||||||
dst.scale = clamp(dst.scale*src.scale, 1/8.0f, 8.0f);
|
dst.scale = std::clamp(dst.scale*src.scale, 1/8.0f, 8.0f);
|
||||||
}
|
}
|
||||||
if(diff & (1<<VSLOT_ROTATION))
|
if(diff & (1<<VSLOT_ROTATION))
|
||||||
{
|
{
|
||||||
dst.rotation = clamp(dst.rotation + src.rotation, 0, 7);
|
dst.rotation = std::clamp(dst.rotation + src.rotation, 0, 7);
|
||||||
if(!dst.offset.iszero()) clampvslotoffset(dst, slot);
|
if(!dst.offset.iszero()) clampvslotoffset(dst, slot);
|
||||||
}
|
}
|
||||||
if(diff & (1<<VSLOT_OFFSET))
|
if(diff & (1<<VSLOT_OFFSET))
|
||||||
|
@ -2162,11 +2164,11 @@ bool unpackvslot(ucharbuf &buf, VSlot &dst, bool delta)
|
||||||
case VSLOT_SCALE:
|
case VSLOT_SCALE:
|
||||||
dst.scale = getfloat(buf);
|
dst.scale = getfloat(buf);
|
||||||
if(dst.scale <= 0) dst.scale = 1;
|
if(dst.scale <= 0) dst.scale = 1;
|
||||||
else if(!delta) dst.scale = clamp(dst.scale, 1/8.0f, 8.0f);
|
else if(!delta) dst.scale = std::clamp(dst.scale, 1/8.0f, 8.0f);
|
||||||
break;
|
break;
|
||||||
case VSLOT_ROTATION:
|
case VSLOT_ROTATION:
|
||||||
dst.rotation = getint(buf);
|
dst.rotation = getint(buf);
|
||||||
if(!delta) dst.rotation = clamp(dst.rotation, 0, 7);
|
if(!delta) dst.rotation = std::clamp(dst.rotation, 0, 7);
|
||||||
break;
|
break;
|
||||||
case VSLOT_OFFSET:
|
case VSLOT_OFFSET:
|
||||||
dst.offset.x = getint(buf);
|
dst.offset.x = getint(buf);
|
||||||
|
@ -2184,19 +2186,19 @@ bool unpackvslot(ucharbuf &buf, VSlot &dst, bool delta)
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case VSLOT_ALPHA:
|
case VSLOT_ALPHA:
|
||||||
dst.alphafront = clamp(getfloat(buf), 0.0f, 1.0f);
|
dst.alphafront = std::clamp(getfloat(buf), 0.0f, 1.0f);
|
||||||
dst.alphaback = clamp(getfloat(buf), 0.0f, 1.0f);
|
dst.alphaback = std::clamp(getfloat(buf), 0.0f, 1.0f);
|
||||||
break;
|
break;
|
||||||
case VSLOT_COLOR:
|
case VSLOT_COLOR:
|
||||||
dst.colorscale.r = clamp(getfloat(buf), 0.0f, 2.0f);
|
dst.colorscale.r = std::clamp(getfloat(buf), 0.0f, 2.0f);
|
||||||
dst.colorscale.g = clamp(getfloat(buf), 0.0f, 2.0f);
|
dst.colorscale.g = std::clamp(getfloat(buf), 0.0f, 2.0f);
|
||||||
dst.colorscale.b = clamp(getfloat(buf), 0.0f, 2.0f);
|
dst.colorscale.b = std::clamp(getfloat(buf), 0.0f, 2.0f);
|
||||||
break;
|
break;
|
||||||
case VSLOT_REFRACT:
|
case VSLOT_REFRACT:
|
||||||
dst.refractscale = clamp(getfloat(buf), 0.0f, 1.0f);
|
dst.refractscale = std::clamp(getfloat(buf), 0.0f, 1.0f);
|
||||||
dst.refractcolor.r = clamp(getfloat(buf), 0.0f, 1.0f);
|
dst.refractcolor.r = std::clamp(getfloat(buf), 0.0f, 1.0f);
|
||||||
dst.refractcolor.g = clamp(getfloat(buf), 0.0f, 1.0f);
|
dst.refractcolor.g = std::clamp(getfloat(buf), 0.0f, 1.0f);
|
||||||
dst.refractcolor.b = clamp(getfloat(buf), 0.0f, 1.0f);
|
dst.refractcolor.b = std::clamp(getfloat(buf), 0.0f, 1.0f);
|
||||||
break;
|
break;
|
||||||
case VSLOT_DETAIL:
|
case VSLOT_DETAIL:
|
||||||
{
|
{
|
||||||
|
@ -2335,7 +2337,7 @@ static void texture(char *type, char *name, int *rot, int *xoffset, int *yoffset
|
||||||
{
|
{
|
||||||
setslotshader(s);
|
setslotshader(s);
|
||||||
VSlot &vs = s.emptyvslot();
|
VSlot &vs = s.emptyvslot();
|
||||||
vs.rotation = clamp(*rot, 0, 7);
|
vs.rotation = std::clamp(*rot, 0, 7);
|
||||||
vs.offset = ivec2(*xoffset, *yoffset).max(0);
|
vs.offset = ivec2(*xoffset, *yoffset).max(0);
|
||||||
vs.scale = *scale <= 0 ? 1 : *scale;
|
vs.scale = *scale <= 0 ? 1 : *scale;
|
||||||
propagatevslot(&vs, (1<<VSLOT_NUM)-1);
|
propagatevslot(&vs, (1<<VSLOT_NUM)-1);
|
||||||
|
@ -2375,7 +2377,7 @@ static void texrotate_(int *rot)
|
||||||
{
|
{
|
||||||
if(!defslot) return;
|
if(!defslot) return;
|
||||||
Slot &s = *defslot;
|
Slot &s = *defslot;
|
||||||
s.variants->rotation = clamp(*rot, 0, 7);
|
s.variants->rotation = std::clamp(*rot, 0, 7);
|
||||||
propagatevslot(s.variants, 1<<VSLOT_ROTATION);
|
propagatevslot(s.variants, 1<<VSLOT_ROTATION);
|
||||||
}
|
}
|
||||||
COMMANDN(texrotate, texrotate_, "i");
|
COMMANDN(texrotate, texrotate_, "i");
|
||||||
|
@ -2411,8 +2413,8 @@ static void texalpha(float *front, float *back)
|
||||||
{
|
{
|
||||||
if(!defslot) return;
|
if(!defslot) return;
|
||||||
Slot &s = *defslot;
|
Slot &s = *defslot;
|
||||||
s.variants->alphafront = clamp(*front, 0.0f, 1.0f);
|
s.variants->alphafront = std::clamp(*front, 0.0f, 1.0f);
|
||||||
s.variants->alphaback = clamp(*back, 0.0f, 1.0f);
|
s.variants->alphaback = std::clamp(*back, 0.0f, 1.0f);
|
||||||
propagatevslot(s.variants, 1<<VSLOT_ALPHA);
|
propagatevslot(s.variants, 1<<VSLOT_ALPHA);
|
||||||
}
|
}
|
||||||
COMMAND(texalpha, "ff");
|
COMMAND(texalpha, "ff");
|
||||||
|
@ -2421,7 +2423,7 @@ static void texcolor(float *r, float *g, float *b)
|
||||||
{
|
{
|
||||||
if(!defslot) return;
|
if(!defslot) return;
|
||||||
Slot &s = *defslot;
|
Slot &s = *defslot;
|
||||||
s.variants->colorscale = vec(clamp(*r, 0.0f, 2.0f), clamp(*g, 0.0f, 2.0f), clamp(*b, 0.0f, 2.0f));
|
s.variants->colorscale = vec(std::clamp(*r, 0.0f, 2.0f), std::clamp(*g, 0.0f, 2.0f), std::clamp(*b, 0.0f, 2.0f));
|
||||||
propagatevslot(s.variants, 1<<VSLOT_COLOR);
|
propagatevslot(s.variants, 1<<VSLOT_COLOR);
|
||||||
}
|
}
|
||||||
COMMAND(texcolor, "fff");
|
COMMAND(texcolor, "fff");
|
||||||
|
@ -2430,9 +2432,9 @@ static void texrefract(float *k, float *r, float *g, float *b)
|
||||||
{
|
{
|
||||||
if(!defslot) return;
|
if(!defslot) return;
|
||||||
Slot &s = *defslot;
|
Slot &s = *defslot;
|
||||||
s.variants->refractscale = clamp(*k, 0.0f, 1.0f);
|
s.variants->refractscale = std::clamp(*k, 0.0f, 1.0f);
|
||||||
if(s.variants->refractscale > 0 && (*r > 0 || *g > 0 || *b > 0))
|
if(s.variants->refractscale > 0 && (*r > 0 || *g > 0 || *b > 0))
|
||||||
s.variants->refractcolor = vec(clamp(*r, 0.0f, 1.0f), clamp(*g, 0.0f, 1.0f), clamp(*b, 0.0f, 1.0f));
|
s.variants->refractcolor = vec(std::clamp(*r, 0.0f, 1.0f), std::clamp(*g, 0.0f, 1.0f), std::clamp(*b, 0.0f, 1.0f));
|
||||||
else
|
else
|
||||||
s.variants->refractcolor = vec(1, 1, 1);
|
s.variants->refractcolor = vec(1, 1, 1);
|
||||||
propagatevslot(s.variants, 1<<VSLOT_REFRACT);
|
propagatevslot(s.variants, 1<<VSLOT_REFRACT);
|
||||||
|
@ -2451,8 +2453,8 @@ static void decaldepth(float *depth, float *fade)
|
||||||
{
|
{
|
||||||
if(!defslot || defslot->type() != Slot::DECAL) return;
|
if(!defslot || defslot->type() != Slot::DECAL) return;
|
||||||
DecalSlot &s = *(DecalSlot *)defslot;
|
DecalSlot &s = *(DecalSlot *)defslot;
|
||||||
s.depth = clamp(*depth, 1e-3f, 1e3f);
|
s.depth = std::clamp(*depth, 1e-3f, 1e3f);
|
||||||
s.fade = clamp(*fade, 0.0f, s.depth);
|
s.fade = std::clamp(*fade, 0.0f, s.depth);
|
||||||
}
|
}
|
||||||
COMMAND(decaldepth, "ff");
|
COMMAND(decaldepth, "ff");
|
||||||
|
|
||||||
|
@ -2461,13 +2463,13 @@ static void addglow(ImageData &c, ImageData &g, const vec &glowcolor)
|
||||||
if(g.bpp < 3)
|
if(g.bpp < 3)
|
||||||
{
|
{
|
||||||
readwritergbtex(c, g,
|
readwritergbtex(c, g,
|
||||||
loopk(3) dst[k] = clamp(int(dst[k]) + int(src[0]*glowcolor[k]), 0, 255);
|
loopk(3) dst[k] = std::clamp(int(dst[k]) + int(src[0]*glowcolor[k]), 0, 255);
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
readwritergbtex(c, g,
|
readwritergbtex(c, g,
|
||||||
loopk(3) dst[k] = clamp(int(dst[k]) + int(src[k]*glowcolor[k]), 0, 255);
|
loopk(3) dst[k] = std::clamp(int(dst[k]) + int(src[k]*glowcolor[k]), 0, 255);
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -3089,9 +3091,9 @@ void initenvmaps()
|
||||||
const extentity &ent = *ents[i];
|
const extentity &ent = *ents[i];
|
||||||
if(ent.type != ET_ENVMAP) continue;
|
if(ent.type != ET_ENVMAP) continue;
|
||||||
envmap &em = envmaps.add();
|
envmap &em = envmaps.add();
|
||||||
em.radius = ent.attr1 ? clamp(int(ent.attr1), 0, 10000) : envmapradius;
|
em.radius = ent.attr1 ? std::clamp(int(ent.attr1), 0, 10000) : envmapradius;
|
||||||
em.size = ent.attr2 ? clamp(int(ent.attr2), 4, 9) : 0;
|
em.size = ent.attr2 ? std::clamp(int(ent.attr2), 4, 9) : 0;
|
||||||
em.blur = ent.attr3 ? clamp(int(ent.attr3), 1, 2) : 0;
|
em.blur = ent.attr3 ? std::clamp(int(ent.attr3), 1, 2) : 0;
|
||||||
em.o = ent.o;
|
em.o = ent.o;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -461,7 +461,7 @@ template<class MDL> struct vertcommands : modelcommands<MDL, struct MDL::vertmes
|
||||||
defformatstring(filename, "%s/%s", MDL::dir, model);
|
defformatstring(filename, "%s/%s", MDL::dir, model);
|
||||||
part &mdl = MDL::loading->addpart();
|
part &mdl = MDL::loading->addpart();
|
||||||
if(mdl.index) mdl.disablepitch();
|
if(mdl.index) mdl.disablepitch();
|
||||||
mdl.meshes = MDL::loading->sharemeshes(path(filename), *smooth > 0 ? cosf(clamp(*smooth, 0.0f, 180.0f)*RAD) : 2);
|
mdl.meshes = MDL::loading->sharemeshes(path(filename), *smooth > 0 ? cosf(std::clamp(*smooth, 0.0f, 180.0f)*RAD) : 2);
|
||||||
if(!mdl.meshes) conoutf("could not load %s", filename);
|
if(!mdl.meshes) conoutf("could not load %s", filename);
|
||||||
else mdl.initskins();
|
else mdl.initskins();
|
||||||
}
|
}
|
||||||
|
|
|
@ -2,6 +2,8 @@
|
||||||
|
|
||||||
#include "world.hh"
|
#include "world.hh"
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
#include <shared/glemu.hh>
|
#include <shared/glemu.hh>
|
||||||
#include <shared/igame.hh>
|
#include <shared/igame.hh>
|
||||||
|
@ -764,7 +766,7 @@ static void renderentradius(extentity &e, bool color)
|
||||||
float radius = e.attached->attr1;
|
float radius = e.attached->attr1;
|
||||||
if(radius <= 0) break;
|
if(radius <= 0) break;
|
||||||
vec dir = vec(e.o).sub(e.attached->o).normalize();
|
vec dir = vec(e.o).sub(e.attached->o).normalize();
|
||||||
float angle = clamp(int(e.attr1), 1, 89);
|
float angle = std::clamp(int(e.attr1), 1, 89);
|
||||||
renderentattachment(e);
|
renderentattachment(e);
|
||||||
renderentcone(*e.attached, dir, radius, angle);
|
renderentcone(*e.attached, dir, radius, angle);
|
||||||
}
|
}
|
||||||
|
@ -877,7 +879,7 @@ void renderentselection(const vec &o, const vec &ray, bool entmoving)
|
||||||
}
|
}
|
||||||
gle::colorub(200,0,0);
|
gle::colorub(200,0,0);
|
||||||
boxs(entorient, eo, es);
|
boxs(entorient, eo, es);
|
||||||
boxs(entorient, eo, es, clamp(0.015f*camera1->o.dist(eo)*tan(fovy*0.5f*RAD), 0.1f, 1.0f));
|
boxs(entorient, eo, es, std::clamp(0.015f*camera1->o.dist(eo)*tan(fovy*0.5f*RAD), 0.1f, 1.0f));
|
||||||
}
|
}
|
||||||
|
|
||||||
if(showentradius)
|
if(showentradius)
|
||||||
|
|
|
@ -4,6 +4,8 @@
|
||||||
|
|
||||||
#include <new>
|
#include <new>
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include <sauerlib/encoding.hh>
|
#include <sauerlib/encoding.hh>
|
||||||
|
|
||||||
#include <shared/command.hh>
|
#include <shared/command.hh>
|
||||||
|
@ -475,7 +477,7 @@ static void loadvslot(stream *f, VSlot &vs, int changed)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if(vs.changed & (1<<VSLOT_SCALE)) vs.scale = f->getlil<float>();
|
if(vs.changed & (1<<VSLOT_SCALE)) vs.scale = f->getlil<float>();
|
||||||
if(vs.changed & (1<<VSLOT_ROTATION)) vs.rotation = clamp(f->getlil<int>(), 0, 7);
|
if(vs.changed & (1<<VSLOT_ROTATION)) vs.rotation = std::clamp(f->getlil<int>(), 0, 7);
|
||||||
if(vs.changed & (1<<VSLOT_OFFSET))
|
if(vs.changed & (1<<VSLOT_OFFSET))
|
||||||
{
|
{
|
||||||
loopk(2) vs.offset[k] = f->getlil<int>();
|
loopk(2) vs.offset[k] = f->getlil<int>();
|
||||||
|
|
|
@ -285,7 +285,8 @@ struct databuf
|
||||||
|
|
||||||
databuf subbuf(int sz)
|
databuf subbuf(int sz)
|
||||||
{
|
{
|
||||||
sz = clamp(sz, 0, maxlen-len);
|
if (sz < 0) sz = 0;
|
||||||
|
if (sz > (maxlen - len)) sz = maxlen - len;
|
||||||
len += sz;
|
len += sz;
|
||||||
return databuf(&buf[len-sz], sz);
|
return databuf(&buf[len-sz], sz);
|
||||||
}
|
}
|
||||||
|
|
|
@ -2,6 +2,8 @@
|
||||||
|
|
||||||
#include <zlib.h>
|
#include <zlib.h>
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
#include "command.hh"
|
#include "command.hh"
|
||||||
|
|
||||||
#include <engine/console.hh> /* conoutf */
|
#include <engine/console.hh> /* conoutf */
|
||||||
|
@ -434,7 +436,7 @@ struct zipstream : stream
|
||||||
case SEEK_SET: pos += info->offset; break;
|
case SEEK_SET: pos += info->offset; break;
|
||||||
default: return false;
|
default: return false;
|
||||||
}
|
}
|
||||||
pos = clamp(pos, offset(info->offset), offset(info->offset + info->size));
|
pos = std::clamp(pos, offset(info->offset), offset(info->offset + info->size));
|
||||||
arch->owner = nullptr;
|
arch->owner = nullptr;
|
||||||
if(fseek(arch->data, int(pos), SEEK_SET) < 0) return false;
|
if(fseek(arch->data, int(pos), SEEK_SET) < 0) return false;
|
||||||
arch->owner = this;
|
arch->owner = this;
|
||||||
|
|
Loading…
Reference in a new issue