Use STL's min and max implementation

Author: MoonPadUSer

src/engine/animmodel.h

@@ -40,8 +40,8 @@ struct animmodel : model
             }
             else
             {
-                fr1 = min(fr1, info.range-1)+info.frame;
-                fr2 = min(fr1+1, info.frame+info.range-1);
+                fr1 = std::min(fr1, info.range - 1) + info.frame;
+                fr2 = std::min(fr1 + 1, info.frame + info.range - 1);
             }
             if(info.anim&ANIM_REVERSE)
             {
@@ -139,8 +139,8 @@ struct animmodel : model
                 gle::color(vec(lightcolor).max(mincolor), trans);
             }
 
-            if(material > 0 && lightmaterial) LOCALPARAM(lightmaterial, lightmaterial[min(material, int(MAXLIGHTMATERIALS))-1].tocolor().mul(2));
-            if(material2 > 0 && lightmaterial) LOCALPARAM(lightmaterial2, lightmaterial[min(material2, int(MAXLIGHTMATERIALS))-1].tocolor().mul(2));
+            if(material > 0 && lightmaterial) LOCALPARAM(lightmaterial, lightmaterial[std::min(material, int(MAXLIGHTMATERIALS)) - 1].tocolor().mul(2));
+            if(material2 > 0 && lightmaterial) LOCALPARAM(lightmaterial2, lightmaterial[std::min(material2, int(MAXLIGHTMATERIALS)) - 1].tocolor().mul(2));
 
             if(key->checkversion() && Shader::lastshader->owner == key) return;
             Shader::lastshader->owner = key;
@@ -153,8 +153,8 @@ struct animmodel : model
             }
             else
             {
-                float bias = max(mincolor-1.0f, 0.2f), scale = 0.5f*max(0.8f-bias, 0.0f),
-                      minshade = scale*max(ambient, mincolor);
+                float bias = std::max(mincolor - 1.0f, 0.2f), scale = 0.5f * std::max(0.8f - bias, 0.0f),
+                      minshade = scale * std::max(ambient, mincolor);
                 LOCALPARAMF(lightscale, scale - minshade, scale, minshade + bias);
             }
             float curglow = glow;
@@ -519,7 +519,7 @@ struct animmodel : model
         virtual int totalframes() const { return 1; }
         bool hasframe(int i) const { return i>=0 && i<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 preload(part *p) {}
@@ -836,7 +836,7 @@ struct animmodel : model
             if(d && interp>=0)
             {
                 animinterpinfo &ai = d->animinterp[interp];
-                if((info.anim&ANIM_CLAMP)==ANIM_CLAMP) aitime = min(aitime, int(info.range*info.speed*0.5e-3f));
+                if((info.anim&ANIM_CLAMP)==ANIM_CLAMP) aitime = std::min(aitime, int(info.range * info.speed * 0.5e-3f));
                 void *ak = meshes->animkey();
                 if(d->ragdoll && !(anim&ANIM_RAGDOLL))
                 {
@@ -1515,7 +1515,7 @@ template<class MDL, class MESH> struct modelcommands
 
     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 setalphablend(char *meshname, int *blend)

src/engine/bih.cpp

@@ -69,7 +69,7 @@ inline bool BIH::traverse(const mesh &m, const vec &o, const vec &ray, const vec
                 if(!curnode->isleaf(faridx))
                 {
                     curnode += curnode->childindex(faridx);
-                    tmin = max(tmin, farsplit);
+                    tmin = std::max(tmin, farsplit);
                     continue;
                 }
                 else if(triintersect(m, curnode->childindex(faridx), mo, mray, maxdist, maxdist, mode))
@@ -91,7 +91,7 @@ inline bool BIH::traverse(const mesh &m, const vec &o, const vec &ray, const vec
                 if(!curnode->isleaf(faridx))
                 {
                     curnode += curnode->childindex(faridx);
-                    tmin = max(tmin, farsplit);
+                    tmin = std::max(tmin, farsplit);
                     continue;
                 }
                 else if(triintersect(m, curnode->childindex(faridx), mo, mray, maxdist, maxdist, mode))
@@ -111,18 +111,18 @@ inline bool BIH::traverse(const mesh &m, const vec &o, const vec &ray, const vec
                     {
                         traversestate &save = stack[stacksize++];
                         save.node = curnode + curnode->childindex(faridx);
-                        save.tmin = max(tmin, farsplit);
+                        save.tmin = std::max(tmin, farsplit);
                         save.tmax = tmax;
                     }
                     else
                     {
-                        if(traverse(m, o, ray, invray, maxdist, maxdist, mode, curnode + curnode->childindex(nearidx), tmin, min(tmax, nearsplit)))
+                        if(traverse(m, o, ray, invray, maxdist, maxdist, mode, curnode + curnode->childindex(nearidx), tmin, std::min(tmax, nearsplit)))
                         {
                             if(mode&RAY_SHADOW) { dist = maxdist; return true; }
                             hit = true;
                         }
                         curnode += curnode->childindex(faridx);
-                        tmin = max(tmin, farsplit);
+                        tmin = std::max(tmin, farsplit);
                         continue;
                     }
                 }
@@ -133,7 +133,7 @@ inline bool BIH::traverse(const mesh &m, const vec &o, const vec &ray, const vec
                 }
             }
             curnode += curnode->childindex(nearidx);
-            tmax = min(tmax, nearsplit);
+            tmax = std::min(tmax, nearsplit);
             continue;
         }
         if(stacksize <= 0) { if(hit) { dist = maxdist; return true; } return false; }
@@ -158,11 +158,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; }
         t1 = (m.bbmin.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;
         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); }
-        tmax = min(tmax, maxdist);
+        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 = std::min(tmax, maxdist);
         if(tmin < tmax && traverse(m, o, ray, invray, maxdist, maxdist, mode, m.nodes, tmin, tmax))
         {
             if(mode&RAY_SHADOW) { dist = maxdist; return true; }
@@ -192,18 +192,18 @@ void BIH::build(mesh &m, ushort *indices, int numindices, const ivec &vmin, cons
             ivec trimin = ivec(tri.center).sub(ivec(tri.radius)),
                  trimax = ivec(tri.center).add(ivec(tri.radius));
             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;
-                splitleft = max(splitleft, amax);
+                splitleft = std::max(splitleft, amax);
                 leftmin.min(trimin);
                 leftmax.max(trimax);
             }
             else
             {
                 --right;
                 std::swap(indices[left], indices[right]);
-                splitright = min(splitright, amin);
+                splitright = std::min(splitright, amin);
                 rightmin.min(trimin);
                 rightmax.max(trimax);
             }
@@ -226,13 +226,13 @@ void BIH::build(mesh &m, ushort *indices, int numindices, const ivec &vmin, cons
                  trimax = ivec(tri.center).add(ivec(tri.radius));
             if(i < left)
             {
-                splitleft = max(splitleft, trimax[axis]);
+                splitleft = std::max(splitleft, trimax[axis]);
                 leftmin.min(trimin);
                 leftmax.max(trimax);
             }
             else
             {
-                splitright = min(splitright, trimin[axis]);
+                splitright = std::min(splitright, trimin[axis]);
                 rightmin.min(trimin);
                 rightmax.max(trimax);
             }
@@ -306,7 +306,7 @@ BIH::BIH(vector<mesh> &buildmeshes)
 
     center = vec(bbmin).add(bbmax).mul(0.5f);
     radius = vec(bbmax).sub(bbmin).mul(0.5f).magnitude();
-    entradius = max(bbmin.squaredlen(), bbmax.squaredlen());
+    entradius = std::max(bbmin.squaredlen(), bbmax.squaredlen());
 
     nodes = new node[numtris];
     node *curnode = nodes;

src/engine/blend.cpp

@@ -139,9 +139,9 @@ bool setblendmaporigin(BlendMapCache *cache, const ivec &o, int size)
     BlendMapBranch *bm = blendmap.branch;
     int bmscale = worldscale-BM_SCALE, bmsize = 1<<bmscale,
         x = o.x>>BM_SCALE, y = o.y>>BM_SCALE,
-        x1 = max(x-1, 0), y1 = max(y-1, 0),
-        x2 = 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),
+        x1 = std::max(x - 1, 0), y1 = std::max(y - 1, 0),
+        x2 = std::min(((o.x + 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);
     if(diff < bmsize) while(!(diff&(1<<(bmscale-1))))
     {
@@ -206,7 +206,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)
 {
-    if(max(x1, y1) <= 0 && min(x2, y2) >= size)
+    if(std::max(x1, y1) <= 0 && std::min(x2, y2) >= size)
     {
         node.cleanup(type);
         type = BM_SOLID;
@@ -220,16 +220,16 @@ static void fillblendmap(uchar &type, BlendMapNode &node, int size, uchar val, i
         if(y1 < size)
         {
             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,
-                                        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(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,
-                                        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;
         node.cleanup(type);
@@ -269,7 +269,7 @@ void fillblendmap(int x, int y, int w, int h, uchar val)
         y1 = clamp(y, 0, bmsize),
         x2 = clamp(x+w, 0, bmsize),
         y2 = 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);
 }
 
@@ -281,16 +281,16 @@ static void invertblendmap(uchar &type, BlendMapNode &node, int size, int x1, in
         if(y1 < 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,
-                                        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(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,
-                                        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;
     }
@@ -316,7 +316,7 @@ void invertblendmap(int x, int y, int w, int h)
         y1 = clamp(y, 0, bmsize),
         x2 = clamp(x+w, 0, bmsize),
         y2 = 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);
 }
 
@@ -395,7 +395,7 @@ static void blitblendmap(uchar &type, BlendMapNode &node, int bmx, int bmy, int
     int x1 = clamp(sx - bmx, 0, bmsize), y1 = clamp(sy - bmy, 0, bmsize),
         x2 = clamp(sx+sw - bmx, 0, bmsize), y2 = clamp(sy+sh - bmy, 0, bmsize);
     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)
     {
         switch(blendpaintmode)
@@ -405,19 +405,19 @@ static void blitblendmap(uchar &type, BlendMapNode &node, int bmx, int bmy, int
                 break;
 
             case 2:
-                loopi(x2 - x1) dst[i] = min(dst[i], src[i]);
+                loopi(x2 - x1) dst[i] = std::min(dst[i], src[i]);
                 break;
 
             case 3:
-                loopi(x2 - x1) dst[i] = max(dst[i], src[i]);
+                loopi(x2 - x1) dst[i] = std::max(dst[i], src[i]);
                 break;
 
             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;
 
             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;
         }
         dst += BM_IMAGE_SIZE;
@@ -428,7 +428,7 @@ static void blitblendmap(uchar &type, BlendMapNode &node, int bmx, int bmy, int
 void blitblendmap(uchar *src, int sx, int sy, int sw, int sh)
 {
     int bmsize = hdr.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);
 }
 
@@ -554,7 +554,7 @@ void addblendbrush(const char *name, const char *imgname)
 
     ImageData s;
     if(!loadimage(imgname, s)) { conoutf("\frcould 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("\frblend brush image size exceeded %dx%d pixels: %s", 1<<12, 1<<12, imgname);
         return;
@@ -738,7 +738,7 @@ void renderblendbrush()
         x2 = x1 + (brush->w << BM_SCALE),
         y2 = y1 + (brush->h << BM_SCALE);
 
-    if(max(x1, y1) >= hdr.worldsize || min(x2, y2) <= 0 || x1>=x2 || y1>=y2) return;
+    if(std::max(x1, y1) >= hdr.worldsize || std::min(x2, y2) <= 0 || x1>=x2 || y1>=y2) return;
 
     if(!brush->tex) brush->gentex();
     renderblendbrush(brush->tex, x1, y1, x2 - x1, y2 - y1);

src/engine/blob.cpp

@@ -123,7 +123,7 @@ struct blobrenderer
         maxindexes = tris*3 + 3;
         availindexes = maxindexes - 3;
         indexes = new ushort[maxindexes];
-        maxverts = min(tris*3/2 + 1, (1<<16)-1);
+        maxverts = std::min(tris * 3 / 2 + 1, (1 << 16) - 1);
         availverts = maxverts - 1;
         verts = new blobvert[maxverts];
     }
@@ -282,7 +282,7 @@ struct blobrenderer
                 dupblob();
                 limit = maxverts - 2;
             }
-            limit = min(int(end - cur), min(limit, (maxindexes - endindex)/3));
+            limit = std::min(int(end - cur), std::min(limit, (maxindexes - endindex) / 3));
             while(availverts < limit+2) if(!freeblob()) return;
             while(availindexes < limit*3) if(!freeblob()) return;
 
@@ -409,7 +409,7 @@ struct blobrenderer
                    m.o[r] + m.rsize >= blobmin[r] && m.o[r] <= blobmax[r])
                 {
                     static cube dummy;
-                    gentris(dummy, m.orient, m.o, max(m.csize, m.rsize), &m);
+                    gentris(dummy, m.orient, m.o, std::max(m.csize, m.rsize), &m);
                 }
                 if(i+1 >= matsurfs) break;
                 materialsurface &n = matbuf[i+1];