OctaForge
/
OctaCore
1
1
Fork 1
Code Issues 1 Pull Requests Releases Wiki Activity

replace a bunch of clamp/min/max with std

master
Daniel Kolesa 2020-07-30 05:26:57 +02:00
parent a2081e6672
commit 6ea2cdb306
28 changed files with 324 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/engine/aa.cc
View File

@ -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)

16
src/engine/animmodel.hh
View File

@ -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)

76
src/engine/bih.cc
View File

@ -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;
} }

142
src/engine/blend.cc
View File

@ -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);

38
src/engine/command.cc
View File

@ -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;

14
src/engine/console.cc
View File

@ -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);

4
src/engine/hitzone.hh
View File

@ -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; \
} \ } \
} \ } \

4
src/engine/light.cc
View File

@ -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;
} }

4
src/engine/lightning.hh
View File

@ -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)

16
src/engine/main.cc
View File

@ -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");

16
src/engine/octa.cc
View File

@ -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));
} }
} }

8
src/engine/octa.hh
View File

@ -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;
} }
}; };

25
src/engine/octaedit.cc
View File

@ -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);
} }

6
src/engine/octarender.cc
View File

@ -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)
{ {

12
src/engine/physics.cc
View File

@ -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;
} }

18
src/engine/rendergl.cc
View File

@ -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);

20
src/engine/renderlights.cc
View File

@ -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);

21
src/engine/rendermodel.cc
View File

@ -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)

14
src/engine/renderparticles.cc
View File

@ -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

8
src/engine/renderva.cc
View File

@ -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;
} }

6
src/engine/shader.cc
View File

@ -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),

18
src/engine/skelmodel.hh
View File

@ -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;
} }

80
src/engine/texture.cc
View File

@ -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;
} }
} }

2
src/engine/vertmodel.hh
View File

@ -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();
} }

6
src/engine/world.cc
View File

@ -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
src/engine/worldio.cc
View File

@ -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>();

3
src/sauerlib/tools.hh
View File

@ -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);
} }

4
src/shared/zip.cc
View File

@ -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;