- Replace MAX() from templates.h with version provided in STL.

# Conflicts:
#	source/common/textures/hw_ihwtexture.cpp
#	source/common/utility/templates.h

source/build/src/polymost.cpp

@@ -3894,7 +3894,7 @@ int32_t polymost_voxdraw(voxmodel_t* m, tspriteptr_t const tspr, bool rotate)
             GLInterface.EnableBlend(true);  // else GLInterface.EnableBlend(false);
     }
     else pc[3] = 1.f;
-    GLInterface.SetShade(std::max(0, globalshade), numshades);
+    GLInterface.SetShade(max(0, globalshade), numshades);
     //------------
 
     //transform to Build coords

source/common/2d/v_draw.cpp

@@ -151,8 +151,8 @@ int GetUIScale(F2DDrawer *drawer, int altval)
 	// block scales that result in something larger than the current screen.
 	int vmax = drawer->GetHeight() / 200;
 	int hmax = drawer->GetWidth() / 320;
-	int max = MAX(vmax, hmax);
+	int max = std::max(vmax, hmax);
-	return MAX(1,MIN(scaleval, max));
+	return std::max(1,MIN(scaleval, max));
 }
 
 // The new console font is twice as high, so the scaling calculation must factor that in.
@@ -172,8 +172,8 @@ int GetConScale(F2DDrawer* drawer, int altval)
 	// block scales that result in something larger than the current screen.
 	int vmax = drawer->GetHeight() / 400;
 	int hmax = drawer->GetWidth() / 640;
-	int max = MAX(vmax, hmax);
+	int max = std::max(vmax, hmax);
-	return MAX(1, MIN(scaleval, max));
+	return std::max(1, MIN(scaleval, max));
 }
 
 

source/common/audio/sound/oalsound.cpp

@@ -579,7 +579,7 @@ OpenALSoundRenderer::OpenALSoundRenderer()
 	// Make sure one source is capable of stereo output with the rest doing
 	// mono, without running out of voices
 	attribs.Push(ALC_MONO_SOURCES);
-	attribs.Push(std::max<ALCint>(snd_channels, 2) - 1);
+	attribs.Push(max<ALCint>(snd_channels, 2) - 1);
 	attribs.Push(ALC_STEREO_SOURCES);
 	attribs.Push(1);
 	if(ALC.SOFT_HRTF)
@@ -681,7 +681,7 @@ OpenALSoundRenderer::OpenALSoundRenderer()
 	// At least Apple's OpenAL implementation returns zeroes,
 	// although it can generate reasonable number of sources.
 
-	const int numChannels = std::max<int>(snd_channels, 2);
+	const int numChannels = max<int>(snd_channels, 2);
 	int numSources = numMono + numStereo;
 
 	if (0 == numSources)
@@ -1346,7 +1346,7 @@ FISoundChannel *OpenALSoundRenderer::StartSound3D(SoundHandle sfx, SoundListener
 		float gain = GetRolloff(rolloff, dist * distscale);
 		// Don't let the ref distance go to 0, or else distance attenuation is
 		// lost with the inverse distance model.
-		alSourcef(source, AL_REFERENCE_DISTANCE, std::max<float>(gain*dist, 0.0004f));
+		alSourcef(source, AL_REFERENCE_DISTANCE, max<float>(gain*dist, 0.0004f));
 		alSourcef(source, AL_MAX_DISTANCE, std::numeric_limits<float>::max());
 		alSourcef(source, AL_ROLLOFF_FACTOR, 1.f);
 	}
@@ -1466,9 +1466,9 @@ void OpenALSoundRenderer::ChannelPitch(FISoundChannel *chan, float pitch)
 
 	ALuint source = GET_PTRID(chan->SysChannel);
 	if (WasInWater && !(chan->ChanFlags & CHANF_UI))
-		alSourcef(source, AL_PITCH, std::max(pitch, 0.0001f)*PITCH_MULT);
+		alSourcef(source, AL_PITCH, max(pitch, 0.0001f)*PITCH_MULT);
 	else
-		alSourcef(source, AL_PITCH, std::max(pitch, 0.0001f));
+		alSourcef(source, AL_PITCH, max(pitch, 0.0001f));
 }
 
 void OpenALSoundRenderer::StopChannel(FISoundChannel *chan)
@@ -1622,7 +1622,7 @@ void OpenALSoundRenderer::UpdateSoundParams3D(SoundListener *listener, FISoundCh
 		{
 			float dist = sqrtf(dist_sqr);
 			float gain = GetRolloff(&chan->Rolloff, dist * chan->DistanceScale);
-			alSourcef(source, AL_REFERENCE_DISTANCE, std::max<float>(gain*dist, 0.0004f));
+			alSourcef(source, AL_REFERENCE_DISTANCE, max<float>(gain*dist, 0.0004f));
 		}
 
 		alSourcei(source, AL_SOURCE_RELATIVE, AL_FALSE);

source/common/audio/sound/s_sound.cpp

@@ -1074,8 +1074,8 @@ void SoundEngine::ChangeSoundPitch(int sourcetype, const void *source, int chann
 void SoundEngine::SetPitch(FSoundChan *chan, float pitch)
 {
 	assert(chan != nullptr);
-	GSnd->ChannelPitch(chan, std::max(0.0001f, pitch));
+	GSnd->ChannelPitch(chan, max(0.0001f, pitch));
-	chan->Pitch = std::max(1, int(float(DEFAULT_PITCH) * pitch));
+	chan->Pitch = max(1, int(float(DEFAULT_PITCH) * pitch));
 }
 
 //==========================================================================

source/common/console/c_commandbuffer.cpp

@@ -144,7 +144,7 @@ void FCommandBuffer::MakeStartPosGood()
 	{ // The cursor is in front of the visible part of the line
 		n = CursorPosCells;
 	}
-	StartPosCells = std::max(0, n);
+	StartPosCells = max(0, n);
 	bool overflow;
 	StartPos = CharsForCells(StartPosCells, &overflow);
 	if (overflow)

source/common/console/c_console.cpp

@@ -856,7 +856,7 @@ static bool C_HandleKey (event_t *ev, FCommandBuffer &buffer)
 			{ // Scroll console buffer down
 				if (ev->subtype == EV_GUI_WheelDown)
 				{
-					RowAdjust = std::max (0, RowAdjust - 3);
+					RowAdjust = max (0, RowAdjust - 3);
 				}
 				else
 				{

source/common/console/c_dispatch.cpp

@@ -1092,7 +1092,7 @@ void C_SearchForPullins(FExecList *exec, const char *file, FCommandLine &argv)
 
 	lastSlash1 = strrchr(file, '/');
 	lastSlash2 = strrchr(file, '\\');
-	lastSlash = MAX(lastSlash1, lastSlash2);
+	lastSlash = max(lastSlash1, lastSlash2);
 #endif
 
 	for (int i = 1; i < argv.argc(); ++i)

source/common/console/c_tabcomplete.cpp

@@ -273,7 +273,7 @@ bool C_TabCompleteList ()
 				}
 			}
 			nummatches++;
-			maxwidth = std::max (maxwidth, strlen (TabCommands[i].TabName.GetChars()));
+			maxwidth = max (maxwidth, strlen (TabCommands[i].TabName.GetChars()));
 		}
 	}
 	if (nummatches > 1)

source/common/cutscenes/movieplayer.cpp

@@ -562,7 +562,7 @@ public:
 		}
 		flags = flags_;
 		Smacker_GetFrameSize(hSMK, nWidth, nHeight);
-		pFrame.Resize(nWidth * nHeight + std::max(nWidth, nHeight));
+		pFrame.Resize(nWidth * nHeight + max(nWidth, nHeight));
 		float frameRate = Smacker_GetFrameRate(hSMK);
 		nFrameNs = uint64_t(1'000'000'000 / frameRate);
 		nFrames = Smacker_GetNumFrames(hSMK);

source/common/fonts/font.cpp

@@ -936,7 +936,7 @@ int FFont::StringWidth(const uint8_t *string, int spacing) const
 		}
 	}
 
-	return std::max(maxw, w);
+	return max(maxw, w);
 }
 
 //==========================================================================

source/common/objects/dobjgc.cpp

@@ -348,7 +348,7 @@ static size_t SingleStep()
 			State = GCS_Finalize;
 		}
 		//assert(old >= AllocBytes);
-		Estimate -= MAX<size_t>(0, old - AllocBytes);
+		Estimate -= max<size_t>(0, old - AllocBytes);
 		return (GCSWEEPMAX - finalize_count) * GCSWEEPCOST + finalize_count * GCFINALIZECOST;
 	  }
 
@@ -625,7 +625,7 @@ CCMD(gc)
 		}
 		else
 		{
-			GC::Pause = MAX(1,atoi(argv[2]));
+			GC::Pause = max(1,atoi(argv[2]));
 		}
 	}
 	else if (stricmp(argv[1], "stepmul") == 0)
@@ -636,7 +636,7 @@ CCMD(gc)
 		}
 		else
 		{
-			GC::StepMul = MAX(100, atoi(argv[2]));
+			GC::StepMul = max(100, atoi(argv[2]));
 		}
 	}
 }

source/common/platform/posix/i_system.h

@@ -66,7 +66,7 @@ static inline char *strlwr(char *str)
 }
 
 inline int I_GetNumaNodeCount() { return 1; }
-inline int I_GetNumaNodeThreadCount(int numaNode) { return std::max<int>(std::thread::hardware_concurrency(), 1); }
+inline int I_GetNumaNodeThreadCount(int numaNode) { return max<int>(std::thread::hardware_concurrency(), 1); }
 inline void I_SetThreadNumaNode(std::thread &thread, int numaNode) { }
 
 #endif

source/common/platform/win32/i_system.cpp

@@ -778,7 +778,7 @@ static HCURSOR CreateAlphaCursor(FBitmap &source, int leftofs, int topofs)
 	// Find closest integer scale factor for the monitor DPI
 	HDC screenDC = GetDC(0);
 	int dpi = GetDeviceCaps(screenDC, LOGPIXELSX);
-	int scale = std::max((dpi + 96 / 2 - 1) / 96, 1);
+	int scale = max((dpi + 96 / 2 - 1) / 96, 1);
 	ReleaseDC(0, screenDC);
 
 	memset(&bi, 0, sizeof(bi));

source/common/platform/win32/st_start_util.cpp

@@ -831,7 +831,7 @@ void FStrifeStartupScreen::DrawStuff(int old_laser, int new_laser)
 		ST_LASERSPACE_X + new_laser, ST_LASERSPACE_Y, ST_LASER_WIDTH, ST_LASER_HEIGHT);
 
 	// The bot jumps up and down like crazy.
-	y = std::max(0, (new_laser >> 1) % 5 - 2);
+	y = max(0, (new_laser >> 1) % 5 - 2);
 	if (y > 0)
 	{
 		ST_Util_ClearBlock(bitmap_info, 0xF0, ST_BOT_X, ST_BOT_Y, ST_BOT_WIDTH, y);

source/common/rendering/hwrenderer/postprocessing/hw_postprocess.cpp

@@ -326,9 +326,9 @@ void PPLensDistort::Render(PPRenderState *renderstate)
 	// Scale factor to keep sampling within the input texture
 	float r2 = aspect * aspect * 0.25f + 0.25f;
 	float sqrt_r2 = sqrt(r2);
-	float f0 = 1.0f + MAX(r2 * (k[0] + kcube[0] * sqrt_r2), 0.0f);
+	float f0 = 1.0f + max(r2 * (k[0] + kcube[0] * sqrt_r2), 0.0f);
-	float f2 = 1.0f + MAX(r2 * (k[2] + kcube[2] * sqrt_r2), 0.0f);
+	float f2 = 1.0f + max(r2 * (k[2] + kcube[2] * sqrt_r2), 0.0f);
-	float f = MAX(f0, f2);
+	float f = max(f0, f2);
 	float scale = 1.0f / f;
 
 	LensUniforms uniforms;
@@ -498,8 +498,8 @@ void PPCameraExposure::Render(PPRenderState *renderstate, int sceneWidth, int sc
 
 void PPCameraExposure::UpdateTextures(int width, int height)
 {
-	int firstwidth = MAX(width / 2, 1);
+	int firstwidth = max(width / 2, 1);
-	int firstheight = MAX(height / 2, 1);
+	int firstheight = max(height / 2, 1);
 
 	if (ExposureLevels.size() > 0 && ExposureLevels[0].Viewport.width == firstwidth && ExposureLevels[0].Viewport.height == firstheight)
 	{
@@ -511,8 +511,8 @@ void PPCameraExposure::UpdateTextures(int width, int height)
 	int i = 0;
 	do
 	{
-		width = MAX(width / 2, 1);
+		width = max(width / 2, 1);
-		height = MAX(height / 2, 1);
+		height = max(height / 2, 1);
 
 		PPExposureLevel blevel;
 		blevel.Viewport.left = 0;
@@ -746,7 +746,7 @@ void PPAmbientOcclusion::Render(PPRenderState *renderstate, float m5, int sceneW
 	LinearDepthUniforms linearUniforms;
 	linearUniforms.SampleIndex = 0;
 	linearUniforms.LinearizeDepthA = 1.0f / screen->GetZFar() - 1.0f / screen->GetZNear();
-	linearUniforms.LinearizeDepthB = MAX(1.0f / screen->GetZNear(), 1.e-8f);
+	linearUniforms.LinearizeDepthB = max(1.0f / screen->GetZNear(), 1.e-8f);
 	linearUniforms.InverseDepthRangeA = 1.0f;
 	linearUniforms.InverseDepthRangeB = 0.0f;
 	linearUniforms.Scale = sceneScale;

source/common/rendering/polyrenderer/drawers/poly_thread.cpp

@@ -100,8 +100,8 @@ void PolyTriangleThreadData::SetScissor(int x, int y, int w, int h)
 
 void PolyTriangleThreadData::UpdateClip()
 {
-	clip.left = MAX(MAX(viewport_x, scissor.left), 0);
+	clip.left = max(max(viewport_x, scissor.left), 0);
-	clip.top = MAX(MAX(viewport_y, scissor.top), 0);
+	clip.top = max(max(viewport_y, scissor.top), 0);
 	clip.right = MIN(MIN(viewport_x + viewport_width, scissor.right), dest_width);
 	clip.bottom = MIN(MIN(viewport_y + viewport_height, scissor.bottom), dest_height);
 }
@@ -210,7 +210,7 @@ void PolyTriangleThreadData::SetStencil(int stencilRef, int op)
 	}
 	else if (op == SOP_Decrement)
 	{
-		StencilWriteValue = MAX(stencilRef - 1, (int)0);
+		StencilWriteValue = max(stencilRef - 1, (int)0);
 	}
 	else // SOP_Keep
 	{
@@ -453,7 +453,7 @@ void PolyTriangleThreadData::DrawShadedLine(const ShadedTriVertex *const* vert)
 	{
 		float clipdistance1 = clipdistance[0 * numclipdistances + p];
 		float clipdistance2 = clipdistance[1 * numclipdistances + p];
-		if (clipdistance1 < 0.0f) t1 = MAX(-clipdistance1 / (clipdistance2 - clipdistance1), t1);
+		if (clipdistance1 < 0.0f) t1 = max(-clipdistance1 / (clipdistance2 - clipdistance1), t1);
 		if (clipdistance2 < 0.0f) t2 = MIN(1.0f + clipdistance2 / (clipdistance1 - clipdistance2), t2);
 		if (t1 >= t2)
 			return;
@@ -792,7 +792,7 @@ int PolyTriangleThreadData::ClipEdge(const ShadedTriVertex *const* verts)
 			// Clip halfspace
 			if ((clipdistance1 >= 0.0f || clipdistance2 >= 0.0f) && outputverts + 1 < max_additional_vertices)
 			{
-				float t1 = (clipdistance1 < 0.0f) ? MAX(-clipdistance1 / (clipdistance2 - clipdistance1), 0.0f) : 0.0f;
+				float t1 = (clipdistance1 < 0.0f) ? max(-clipdistance1 / (clipdistance2 - clipdistance1), 0.0f) : 0.0f;
 				float t2 = (clipdistance2 < 0.0f) ? MIN(1.0f + clipdistance2 / (clipdistance1 - clipdistance2), 1.0f) : 1.0f;
 
 				// add t1 vertex

source/common/rendering/polyrenderer/drawers/poly_thread.h

@@ -85,7 +85,7 @@ public:
 
 	int skipped_by_thread(int first_line)
 	{
-		int clip_first_line = MAX(first_line, numa_start_y);
+		int clip_first_line = max(first_line, numa_start_y);
 		int core_skip = (num_cores - (clip_first_line - core) % num_cores) % num_cores;
 		return clip_first_line + core_skip - first_line;
 	}
@@ -94,7 +94,7 @@ public:
 	{
 		count = MIN(count, numa_end_y - first_line);
 		int c = (count - skipped_by_thread(first_line) + num_cores - 1) / num_cores;
-		return MAX(c, 0);
+		return max(c, 0);
 	}
 
 	struct Scanline

source/common/rendering/polyrenderer/drawers/screen_blend.cpp

@@ -514,10 +514,10 @@ void BlendColorRevSub_Src_One(int y, int x0, int x1, PolyTriangleThreadData* thr
 		uint32_t srcscale = APART(src);
 		srcscale += srcscale >> 7;
 
-		uint32_t a = MAX<int32_t>(APART(dst) - (((APART(src) * srcscale) + 127) >> 8), 0);
+		uint32_t a = max<int32_t>(APART(dst) - (((APART(src) * srcscale) + 127) >> 8), 0);
-		uint32_t r = MAX<int32_t>(RPART(dst) - (((RPART(src) * srcscale) + 127) >> 8), 0);
+		uint32_t r = max<int32_t>(RPART(dst) - (((RPART(src) * srcscale) + 127) >> 8), 0);
-		uint32_t g = MAX<int32_t>(GPART(dst) - (((GPART(src) * srcscale) + 127) >> 8), 0);
+		uint32_t g = max<int32_t>(GPART(dst) - (((GPART(src) * srcscale) + 127) >> 8), 0);
-		uint32_t b = MAX<int32_t>(BPART(dst) - (((BPART(src) * srcscale) + 127) >> 8), 0);
+		uint32_t b = max<int32_t>(BPART(dst) - (((BPART(src) * srcscale) + 127) >> 8), 0);
 
 		line[x] = MAKEARGB(a, r, g, b);
 	}

source/common/rendering/polyrenderer/drawers/screen_scanline_setup.cpp

@@ -202,7 +202,7 @@ static void WriteDynLightArray(int x0, int x1, PolyTriangleThreadData* thread)
 			Ly *= rcp_dist;
 			Lz *= rcp_dist;
 			float dotNL = worldnormalX * Lx + worldnormalY * Ly + worldnormalZ * Lz;
-			float point_attenuation = MAX(dotNL, 0.0f) * distance_attenuation;
+			float point_attenuation = max(dotNL, 0.0f) * distance_attenuation;
 
 			uint32_t attenuation = (uint32_t)(is_attenuated ? (int32_t)point_attenuation : (int32_t)simple_attenuation);
 
@@ -327,7 +327,7 @@ static void WriteLightArray(int y, int x0, int x1, const TriDrawTriangleArgs* ar
 			uint32_t g = thread->scanline.vColorG[x];
 			uint32_t b = thread->scanline.vColorB[x];
 
-			float fogdist = MAX(16.0f, w[x]);
+			float fogdist = max(16.0f, w[x]);
 			float fogfactor = std::exp2(constants->uFogDensity * fogdist);
 
 			// brightening around the player for light mode 2:

source/common/rendering/polyrenderer/drawers/screen_shader.cpp

@@ -473,7 +473,7 @@ static void GetLightColor(int x0, int x1, PolyTriangleThreadData* thread)
 			mulG += mulG >> 7;
 			mulB += mulB >> 7;
 
-			float fogdist = MAX(16.0f, w[x]);
+			float fogdist = max(16.0f, w[x]);
 			float fogfactor = std::exp2(uFogDensity * fogdist);
 
 			uint32_t a = (APART(fg) * mulA + 127) >> 8;
@@ -512,7 +512,7 @@ static void MainFP(int x0, int x1, PolyTriangleThreadData* thread)
 			float fogfactor = 0.0f;
 			if (constants->uFogEnabled != 0)
 			{
-				fogdist = MAX(16.0f, w[x]);
+				fogdist = max(16.0f, w[x]);
 				fogfactor = std::exp2(constants->uFogDensity * fogdist);
 			}
 			frag = vec4(uFogColor.rgb, (1.0 - fogfactor) * frag.a * 0.75 * vColor.a);*/

source/common/rendering/polyrenderer/drawers/screen_triangle.cpp

@@ -207,7 +207,7 @@ void ScreenTriangle::Draw(const TriDrawTriangleArgs* args, PolyTriangleThreadDat
 	SortVertices(args, sortedVertices);
 
 	int clipleft = thread->clip.left;
-	int cliptop = MAX(thread->clip.top, thread->numa_start_y);
+	int cliptop = max(thread->clip.top, thread->numa_start_y);
 	int clipright = thread->clip.right;
 	int clipbottom = MIN(thread->clip.bottom, thread->numa_end_y);
 
@@ -215,7 +215,7 @@ void ScreenTriangle::Draw(const TriDrawTriangleArgs* args, PolyTriangleThreadDat
 	int midY = (int)(sortedVertices[1]->y + 0.5f);
 	int bottomY = (int)(sortedVertices[2]->y + 0.5f);
 
-	topY = MAX(topY, cliptop);
+	topY = max(topY, cliptop);
 	midY = MIN(midY, clipbottom);
 	bottomY = MIN(bottomY, clipbottom);
 

source/common/rendering/r_thread.h

@@ -78,7 +78,7 @@ public:
 	// The number of lines to skip to reach the first line to be rendered by this thread
 	int skipped_by_thread(int first_line)
 	{
-		int clip_first_line = MAX(first_line, numa_start_y);
+		int clip_first_line = max(first_line, numa_start_y);
 		int core_skip = (num_cores - (clip_first_line - core) % num_cores) % num_cores;
 		return clip_first_line + core_skip - first_line;
 	}
@@ -88,7 +88,7 @@ public:
 	{
 		count = MIN(count, numa_end_y - first_line);
 		int c = (count - skipped_by_thread(first_line) + num_cores - 1) / num_cores;
-		return MAX(c, 0);
+		return max(c, 0);
 	}
 
 	// Calculate the dest address for the first line to be rendered by this thread

source/common/rendering/r_videoscale.cpp

@@ -193,7 +193,7 @@ int ViewportScaledWidth(int width, int height)
 		width = ((float)width/height > ActiveRatio(width, height)) ? (int)(height * ActiveRatio(width, height)) : width;
 		height = ((float)width/height < ActiveRatio(width, height)) ? (int)(width / ActiveRatio(width, height)) : height;
 	}
-	return (int)std::max((int32_t)min_width, (int32_t)(vid_scalefactor * vScaleTable[vid_scalemode].GetScaledWidth(width, height)));
+	return (int)max((int32_t)min_width, (int32_t)(vid_scalefactor * vScaleTable[vid_scalemode].GetScaledWidth(width, height)));
 }
 
 int ViewportScaledHeight(int width, int height)
@@ -205,7 +205,7 @@ int ViewportScaledHeight(int width, int height)
 		height = ((float)width/height < ActiveRatio(width, height)) ? (int)(width / ActiveRatio(width, height)) : height;
 		width = ((float)width/height > ActiveRatio(width, height)) ? (int)(height * ActiveRatio(width, height)) : width;
 	}
-	return (int)std::max((int32_t)min_height, (int32_t)(vid_scalefactor * vScaleTable[vid_scalemode].GetScaledHeight(width, height)));
+	return (int)max((int32_t)min_height, (int32_t)(vid_scalefactor * vScaleTable[vid_scalemode].GetScaledHeight(width, height)));
 }
 
 float ViewportPixelAspect()

source/common/rendering/v_video.cpp

@@ -252,7 +252,7 @@ void DCanvas::Resize(int width, int height, bool optimizepitch)
 		}
 		else
 		{
-			Pitch = width + MAX(0, CPU.DataL1LineSize - 8);
+			Pitch = width + max(0, CPU.DataL1LineSize - 8);
 		}
 	}
 	int bytes_per_pixel = Bgra ? 4 : 1;
@@ -275,7 +275,7 @@ void V_UpdateModeSize (int width, int height)
 
 	// This reference size is being used so that on 800x450 (small 16:9) a scale of 2 gets used.
 
-	CleanXfac = std::max(std::min(screen->GetWidth() / 400, screen->GetHeight() / 240), 1);
+	CleanXfac = max(std::min(screen->GetWidth() / 400, screen->GetHeight() / 240), 1);
 	if (CleanXfac >= 4) CleanXfac--;	// Otherwise we do not have enough space for the episode/skill menus in some languages.
 	CleanYfac = CleanXfac;
 	CleanWidth = screen->GetWidth() / CleanXfac;
@@ -292,7 +292,7 @@ void V_UpdateModeSize (int width, int height)
 	else if (w < 1920) factor = 2;
 	else factor = int(factor * 0.7);
 
-	CleanYfac_1 = CleanXfac_1 = factor;// MAX(1, int(factor * 0.7));
+	CleanYfac_1 = CleanXfac_1 = factor;// max(1, int(factor * 0.7));
 	CleanWidth_1 = width / CleanXfac_1;
 	CleanHeight_1 = height / CleanYfac_1;
 

source/common/rendering/vulkan/renderer/vk_renderstate.cpp

@@ -228,7 +228,7 @@ void VkRenderState::ApplyRenderPass(int dt)
 	pipelineKey.ColorMask = mColorMask;
 	pipelineKey.CullMode = mCullMode;
 	pipelineKey.NumTextureLayers = mMaterial.mMaterial ? mMaterial.mMaterial->NumLayers() : 0;
-	pipelineKey.NumTextureLayers = std::max(pipelineKey.NumTextureLayers, SHADER_MIN_REQUIRED_TEXTURE_LAYERS);// Always force minimum 8 textures as the shader requires it
+	pipelineKey.NumTextureLayers = max(pipelineKey.NumTextureLayers, SHADER_MIN_REQUIRED_TEXTURE_LAYERS);// Always force minimum 8 textures as the shader requires it
 	if (mSpecialEffect > EFF_NONE)
 	{
 		pipelineKey.SpecialEffect = mSpecialEffect;

source/common/rendering/vulkan/system/vk_buffers.cpp

@@ -73,7 +73,7 @@ void VKBuffer::SetData(size_t size, const void *data, BufferUsageType usage)
 {
 	auto fb = GetVulkanFrameBuffer();
 
-	size_t bufsize = std::max(size, (size_t)16); // For supporting zero byte buffers
+	size_t bufsize = max(size, (size_t)16); // For supporting zero byte buffers
 
 	// If SetData is called multiple times we have to keep the old buffers alive as there might still be draw commands referencing them
 	if (mBuffer)
@@ -153,7 +153,7 @@ void VKBuffer::SetData(size_t size, const void *data, BufferUsageType usage)
 
 void VKBuffer::SetSubData(size_t offset, size_t size, const void *data)
 {
-	size = std::max(size, (size_t)16); // For supporting zero byte buffers
+	size = max(size, (size_t)16); // For supporting zero byte buffers
 
 	auto fb = GetVulkanFrameBuffer();
 	if (mStaging)
@@ -174,7 +174,7 @@ void VKBuffer::SetSubData(size_t offset, size_t size, const void *data)
 
 void VKBuffer::Resize(size_t newsize)
 {
-	newsize = std::max(newsize, (size_t)16); // For supporting zero byte buffers
+	newsize = max(newsize, (size_t)16); // For supporting zero byte buffers
 
 	auto fb = GetVulkanFrameBuffer();
 
@@ -222,7 +222,7 @@ void VKBuffer::Unmap()
 
 void *VKBuffer::Lock(unsigned int size)
 {
-	size = std::max(size, (unsigned int)16); // For supporting zero byte buffers
+	size = max(size, (unsigned int)16); // For supporting zero byte buffers
 
 	if (!mBuffer)
 	{

source/common/rendering/vulkan/system/vk_builders.h

@@ -571,7 +571,7 @@ inline BufferBuilder::BufferBuilder()
 
 inline void BufferBuilder::setSize(size_t size)
 {
-	bufferInfo.size = std::max(size, (size_t)16);
+	bufferInfo.size = max(size, (size_t)16);
 }
 
 inline void BufferBuilder::setUsage(VkBufferUsageFlags bufferUsage, VmaMemoryUsage memoryUsage, VmaAllocationCreateFlags allocFlags)

source/common/rendering/vulkan/system/vk_framebuffer.cpp

@@ -628,7 +628,7 @@ void VulkanFrameBuffer::UpdateGpuStats()
 		if (q.endIndex <= q.startIndex)
 			continue;
 
-		int64_t timeElapsed = std::max(static_cast<int64_t>(timestamps[q.endIndex] - timestamps[q.startIndex]), (int64_t)0);
+		int64_t timeElapsed = max(static_cast<int64_t>(timestamps[q.endIndex] - timestamps[q.startIndex]), (int64_t)0);
 		double timeNS = timeElapsed * timestampPeriod;
 
 		FString out;

source/common/rendering/vulkan/system/vk_swapchain.cpp

@@ -161,8 +161,8 @@ bool VulkanSwapChain::CreateSwapChain(VkSwapchainKHR oldSwapChain)
 	VkSurfaceCapabilitiesKHR surfaceCapabilities = GetSurfaceCapabilities();
 
 	actualExtent = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) };
-	actualExtent.width = std::max(surfaceCapabilities.minImageExtent.width, std::min(surfaceCapabilities.maxImageExtent.width, actualExtent.width));
+	actualExtent.width = max(surfaceCapabilities.minImageExtent.width, std::min(surfaceCapabilities.maxImageExtent.width, actualExtent.width));
-	actualExtent.height = std::max(surfaceCapabilities.minImageExtent.height, std::min(surfaceCapabilities.maxImageExtent.height, actualExtent.height));
+	actualExtent.height = max(surfaceCapabilities.minImageExtent.height, std::min(surfaceCapabilities.maxImageExtent.height, actualExtent.height));
 	if (actualExtent.width == 0 || actualExtent.height == 0)
 	{
 		swapChain = VK_NULL_HANDLE;

source/common/rendering/vulkan/textures/vk_hwtexture.cpp

@@ -218,8 +218,8 @@ int VkHardwareTexture::GetMipLevels(int w, int h)
 	int levels = 1;
 	while (w > 1 || h > 1)
 	{
-		w = std::max(w >> 1, 1);
+		w = max(w >> 1, 1);
-		h = std::max(h >> 1, 1);
+		h = max(h >> 1, 1);
 		levels++;
 	}
 	return levels;
@@ -391,7 +391,7 @@ VulkanDescriptorSet* VkMaterial::GetDescriptorSet(const FMaterialState& state)
 	int numLayers = NumLayers();
 
 	auto fb = GetVulkanFrameBuffer();
-	auto descriptor = fb->GetRenderPassManager()->AllocateTextureDescriptorSet(std::max(numLayers, SHADER_MIN_REQUIRED_TEXTURE_LAYERS));
+	auto descriptor = fb->GetRenderPassManager()->AllocateTextureDescriptorSet(max(numLayers, SHADER_MIN_REQUIRED_TEXTURE_LAYERS));
 
 	descriptor->SetDebugName("VkHardwareTexture.mDescriptorSets");
 

source/common/rendering/vulkan/textures/vk_imagetransition.cpp

@@ -117,8 +117,8 @@ void VkTextureImage::GenerateMipmaps(VulkanCommandBuffer *cmdbuffer)
 		barrier0.execute(cmdbuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
 		Layout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
 
-		int nextWidth = std::max(mipWidth >> 1, 1);
+		int nextWidth = max(mipWidth >> 1, 1);
-		int nextHeight = std::max(mipHeight >> 1, 1);
+		int nextHeight = max(mipHeight >> 1, 1);
 
 		VkImageBlit blit = {};
 		blit.srcOffsets[0] = { 0, 0, 0 };

source/common/rendering/vulkan/thirdparty/vk_mem_alloc/vk_mem_alloc.h

@@ -18473,8 +18473,8 @@ VkMemoryRequirements img2MemReq;
 vkGetImageMemoryRequirements(device, img2, &img2MemReq);
 
 VkMemoryRequirements finalMemReq = {};
-finalMemReq.size = std::max(img1MemReq.size, img2MemReq.size);
+finalMemReq.size = max(img1MemReq.size, img2MemReq.size);
-finalMemReq.alignment = std::max(img1MemReq.alignment, img2MemReq.alignment);
+finalMemReq.alignment = max(img1MemReq.alignment, img2MemReq.alignment);
 finalMemReq.memoryTypeBits = img1MemReq.memoryTypeBits & img2MemReq.memoryTypeBits;
 // Validate if(finalMemReq.memoryTypeBits != 0)
 

source/common/scripting/backend/codegen.cpp

@@ -8896,7 +8896,7 @@ ExpEmit FxVMFunctionCall::Emit(VMFunctionBuilder *build)
 	ArgList.ShrinkToFit();
 
 	if (!staticcall) emitters.SetVirtualReg(selfemit.RegNum);
-	int resultcount = vmfunc->Proto->ReturnTypes.Size() == 0 ? 0 : std::max(AssignCount, 1);
+	int resultcount = vmfunc->Proto->ReturnTypes.Size() == 0 ? 0 : max(AssignCount, 1);
 
 	assert((unsigned)resultcount <= vmfunc->Proto->ReturnTypes.Size());
 	for (int i = 0; i < resultcount; i++)

source/common/scripting/core/symbols.cpp

@@ -345,7 +345,7 @@ PField *PSymbolTable::AddField(FName name, PType *type, uint32_t flags, unsigned
 	// its fields.
 	if (Align != nullptr)
 	{
-		*Align = MAX(*Align, type->Align);
+		*Align = max(*Align, type->Align);
 	}
 
 	if (AddSymbol(field) == nullptr)

source/common/scripting/core/vmdisasm.cpp

@@ -677,7 +677,7 @@ static int print_reg(FILE *out, int col, int arg, int mode, int immshift, const
 void DumpFunction(FILE *dump, VMScriptFunction *sfunc, const char *label, int labellen)
 {
 	const char *marks = "=======================================================";
-	fprintf(dump, "\n%.*s %s %.*s", MAX(3, 38 - labellen / 2), marks, label, MAX(3, 38 - labellen / 2), marks);
+	fprintf(dump, "\n%.*s %s %.*s", max(3, 38 - labellen / 2), marks, label, max(3, 38 - labellen / 2), marks);
 	fprintf(dump, "\nInteger regs: %-3d  Float regs: %-3d  Address regs: %-3d  String regs: %-3d\nStack size: %d\n",
 		sfunc->NumRegD, sfunc->NumRegF, sfunc->NumRegA, sfunc->NumRegS, sfunc->MaxParam);
 	VMDumpConstants(dump, sfunc);

source/common/scripting/jit/jit_runtime.cpp

@@ -56,7 +56,7 @@ static void *AllocJitMemory(size_t size)
 	}
 	else
 	{
-		const size_t bytesToAllocate = std::max(size_t(1024 * 1024), size);
+		const size_t bytesToAllocate = max(size_t(1024 * 1024), size);
 		size_t allocatedSize = 0;
 		void *p = OSUtils::allocVirtualMemory(bytesToAllocate, &allocatedSize, OSUtils::kVMWritable | OSUtils::kVMExecutable);
 		if (!p)

source/common/scripting/vm/vmframe.cpp

@@ -746,7 +746,7 @@ ADD_STAT(VM)
 	for (auto d : VMCycles)
 	{
 		added += d.TimeMS();
-		peak = MAX<double>(peak, d.TimeMS());
+		peak = max<double>(peak, d.TimeMS());
 	}
 	for (auto d : VMCalls) addedc += d;
 	memmove(&VMCycles[1], &VMCycles[0], 9 * sizeof(cycle_t));

source/common/statusbar/base_sbar.cpp

@@ -293,11 +293,11 @@ static void ST_CalcCleanFacs(int designwidth, int designheight, int realwidth, i
 	}
 	// Use whichever pair of cwidth/cheight or width/height that produces less difference
 	// between CleanXfac and CleanYfac.
-	cx1 = MAX(cwidth / designwidth, 1);
+	cx1 = max(cwidth / designwidth, 1);
-	cy1 = MAX(cheight / designheight, 1);
+	cy1 = max(cheight / designheight, 1);
-	cx2 = MAX(realwidth / designwidth, 1);
+	cx2 = max(realwidth / designwidth, 1);
-	cy2 = MAX(realheight / designheight, 1);
+	cy2 = max(realheight / designheight, 1);
-	if (abs(cx1 - cy1) <= abs(cx2 - cy2) || MAX(cx1, cx2) >= 4)
+	if (abs(cx1 - cy1) <= abs(cx2 - cy2) || max(cx1, cx2) >= 4)
 	{ // e.g. 640x360 looks better with this.
 		*cleanx = cx1;
 		*cleany = cy1;

source/common/textures/bitmap.h

@@ -460,7 +460,7 @@ struct bCopyAlpha
 struct bOverlay
 {	
 	static __forceinline void OpC(uint8_t &d, uint8_t s, uint8_t a, FCopyInfo *i) { d = (s*a + d*(255-a))/255; }
-	static __forceinline void OpA(uint8_t &d, uint8_t s, FCopyInfo *i) { d = MAX(s,d); }
+	static __forceinline void OpA(uint8_t &d, uint8_t s, FCopyInfo *i) { d = max(s,d); }
 	static __forceinline bool ProcessAlpha0() { return false; }
 };
 
@@ -480,14 +480,14 @@ struct bAdd
 
 struct bSubtract
 {
-	static __forceinline void OpC(uint8_t &d, uint8_t s, uint8_t a, FCopyInfo *i) { d = MAX<int>((d*BLENDUNIT - s*i->alpha) >> BLENDBITS, 0); }
+	static __forceinline void OpC(uint8_t &d, uint8_t s, uint8_t a, FCopyInfo *i) { d = max<int>((d*BLENDUNIT - s*i->alpha) >> BLENDBITS, 0); }
 	static __forceinline void OpA(uint8_t &d, uint8_t s, FCopyInfo *i) { d = s; }
 	static __forceinline bool ProcessAlpha0() { return false; }
 };
 
 struct bReverseSubtract
 {
-	static __forceinline void OpC(uint8_t &d, uint8_t s, uint8_t a, FCopyInfo *i) { d = MAX<int>((-d*BLENDUNIT + s*i->alpha) >> BLENDBITS, 0); }
+	static __forceinline void OpC(uint8_t &d, uint8_t s, uint8_t a, FCopyInfo *i) { d = max<int>((-d*BLENDUNIT + s*i->alpha) >> BLENDBITS, 0); }
 	static __forceinline void OpA(uint8_t &d, uint8_t s, FCopyInfo *i) { d = s; }
 	static __forceinline bool ProcessAlpha0() { return false; }
 };

source/common/textures/hw_ihwtexture.cpp

@@ -67,8 +67,8 @@ static void ResampleBoxPrecalc(TArray<BoxPrecalc>& boxes, int oldDim)
 		const int src_p = int(dst * scale_factor_1);
 
 		BoxPrecalc& precalc = boxes[dst];
-		precalc.boxStart = clamp<int>(int(src_p - scale_factor_1 / 2.0 + 1), 0, oldDim - 1);
+		precalc.boxStart = std::clamp<int>(int(src_p - scale_factor_1 / 2.0 + 1), 0, oldDim - 1);
-		precalc.boxEnd = clamp<int>(max<int>(precalc.boxStart + 1, int(src_p + scale_factor_2)), 0, oldDim - 1);
+		precalc.boxEnd = std::clamp<int>(std::max<int>(precalc.boxStart + 1, int(src_p + scale_factor_2)), 0, oldDim - 1);
 	}
 }
 

source/common/textures/texture.cpp

@@ -387,7 +387,7 @@ FTextureBuffer FTexture::CreateTexBuffer(int translation, int flags)
 			FContentIdBuilder builder;
 			builder.id = 0;
 			builder.imageID = GetImage()->GetId();
-			builder.translation = MAX(0, translation);
+			builder.translation = max(0, translation);
 			builder.expand = exx;
 			result.mContentId = builder.id;
 		}

source/common/thirdparty/earcut.hpp

@@ -132,7 +132,7 @@ private:
                 alloc_traits::deallocate(alloc, allocation, blockSize);
             }
             allocations.clear();
-            blockSize = std::max<std::size_t>(1, newBlockSize);
+            blockSize = max<std::size_t>(1, newBlockSize);
             currentBlock = nullptr;
             currentIndex = blockSize;
         }
@@ -186,13 +186,13 @@ void Earcut<N>::operator()(const Polygon& points) {
             y = p->y;
             minX = std::min<double>(minX, x);
             minY = std::min<double>(minY, y);
-            maxX = std::max<double>(maxX, x);
+            maxX = max<double>(maxX, x);
-            maxY = std::max<double>(maxY, y);
+            maxY = max<double>(maxY, y);
             p = p->next;
         } while (p != outerNode);
 
         // minX, minY and size are later used to transform coords into integers for z-order calculation
-        inv_size = std::max<double>(maxX - minX, maxY - minY);
+        inv_size = max<double>(maxX - minX, maxY - minY);
         inv_size = inv_size != .0 ? (1. / inv_size) : .0;
     }
 
@@ -352,8 +352,8 @@ bool Earcut<N>::isEarHashed(Node* ear) {
     // triangle bbox; min & max are calculated like this for speed
     const double minTX = std::min<double>(a->x, std::min<double>(b->x, c->x));
     const double minTY = std::min<double>(a->y, std::min<double>(b->y, c->y));
-    const double maxTX = std::max<double>(a->x, std::max<double>(b->x, c->x));
+    const double maxTX = max<double>(a->x, max<double>(b->x, c->x));
-    const double maxTY = std::max<double>(a->y, std::max<double>(b->y, c->y));
+    const double maxTY = max<double>(a->y, max<double>(b->y, c->y));
 
     // z-order range for the current triangle bbox;
     const int32_t minZ = zOrder(minTX, minTY);
@@ -717,9 +717,9 @@ bool Earcut<N>::intersects(const Node* p1, const Node* q1, const Node* p2, const
 // for collinear points p, q, r, check if point q lies on segment pr
 template <typename N>
 bool Earcut<N>::onSegment(const Node* p, const Node* q, const Node* r) {
-    return q->x <= std::max<double>(p->x, r->x) &&
+    return q->x <= max<double>(p->x, r->x) &&
         q->x >= std::min<double>(p->x, r->x) &&
-        q->y <= std::max<double>(p->y, r->y) &&
+        q->y <= max<double>(p->y, r->y) &&
         q->y >= std::min<double>(p->y, r->y);
 }
 

source/common/utility/palette.cpp

@@ -500,7 +500,7 @@ PalEntry averageColor(const uint32_t* data, int size, int maxout)
 	g = g / size;
 	b = b / size;
 
-	int maxv = MAX(MAX(r, g), b);
+	int maxv = max(max(r, g), b);
 
 	if (maxv && maxout)
 	{

source/common/utility/templates.h

@@ -111,23 +111,5 @@ const T MIN (const T a, const T b)
 	return a < b ? a : b;
 }
 
-//==========================================================================
-//
-// MAX
-//
-// Returns the maximum of a and b.
-//==========================================================================
-
-#ifdef MAX
-#undef MAX
-#endif
-
-template<class T>
-inline
-const T MAX (const T a, const T b)
-{
-	return a > b ? a : b;
-}
-
 
 #endif //__TEMPLATES_H__

source/core/d_net.cpp

@@ -234,7 +234,7 @@ static struct TicSpecial
 	{
 		int i;
 
-		specialsize = std::max(specialsize * 2, needed + 30);
+		specialsize = max(specialsize * 2, needed + 30);
 
 		DPrintf (DMSG_NOTIFY, "Expanding special size to %zu\n", specialsize);
 
@@ -1164,7 +1164,7 @@ void NetUpdate (void)
 			netbuffer[k++] = lowtic;
 		}
 
-		numtics = std::max(0, lowtic - realstart);
+		numtics = max(0, lowtic - realstart);
 		if (numtics > BACKUPTICS)
 			I_Error ("NetUpdate: Node %d missed too many tics", i);
 
@@ -1173,7 +1173,7 @@ void NetUpdate (void)
 		case 0:
 		default: 
 			resendto[i] = lowtic; break;
-		case 1: resendto[i] = std::max(0, lowtic - 1); break;
+		case 1: resendto[i] = max(0, lowtic - 1); break;
 		case 2: resendto[i] = nettics[i]; break;
 		}
 
@@ -1998,15 +1998,15 @@ int Net_GetLatency(int *ld, int *ad)
 	localdelay = ((localdelay / BACKUPTICS) * ticdup) * (1000 / GameTicRate);
 	int severity = 0;
 
-	if (std::max(localdelay, arbitratordelay) > 200)
+	if (max(localdelay, arbitratordelay) > 200)
 	{
 		severity = 1;
 	}
-	if (std::max(localdelay, arbitratordelay) > 400)
+	if (max(localdelay, arbitratordelay) > 400)
 	{
 		severity = 2;
 	}
-	if (std::max(localdelay, arbitratordelay) >= ((BACKUPTICS / 2 - 1) * ticdup) * (1000 / GameTicRate))
+	if (max(localdelay, arbitratordelay) >= ((BACKUPTICS / 2 - 1) * ticdup) * (1000 / GameTicRate))
 	{
 		severity = 3;
 	}

source/core/nodebuilder/nodebuild.cpp

@@ -141,10 +141,10 @@ int FNodeBuilder::CreateNode (uint32_t set, unsigned int count, fixed_t bbox[4])
 		D(PrintSet (2, set2));
 		node.intchildren[0] = CreateNode (set1, count1, node.nb_bbox[0]);
 		node.intchildren[1] = CreateNode (set2, count2, node.nb_bbox[1]);
-		bbox[BOXTOP] = MAX (node.nb_bbox[0][BOXTOP], node.nb_bbox[1][BOXTOP]);
+		bbox[BOXTOP] = max(node.nb_bbox[0][BOXTOP], node.nb_bbox[1][BOXTOP]);
 		bbox[BOXBOTTOM] = MIN (node.nb_bbox[0][BOXBOTTOM], node.nb_bbox[1][BOXBOTTOM]);
 		bbox[BOXLEFT] = MIN (node.nb_bbox[0][BOXLEFT], node.nb_bbox[1][BOXLEFT]);
-		bbox[BOXRIGHT] = MAX (node.nb_bbox[0][BOXRIGHT], node.nb_bbox[1][BOXRIGHT]);
+		bbox[BOXRIGHT] = max(node.nb_bbox[0][BOXRIGHT], node.nb_bbox[1][BOXRIGHT]);
 		return (int)Nodes.Push (node);
 	}
 	else
@@ -630,7 +630,7 @@ int FNodeBuilder::Heuristic (node_t &node, uint32_t set, bool honorNoSplit)
 					frac = 1 - frac;
 				}
 				int penalty = int(1 / frac);
-				score = MAX(score - penalty, 1);
+				score = std::max(score - penalty, 1);
 				D(Printf ("Penalized splitter by %d for being near endpt of seg %d (%f).\n", penalty, i, frac));
 			}
 

source/core/nodebuilder/nodebuild_utility.cpp

@@ -450,9 +450,9 @@ int FNodeBuilder::FVertexMap::InsertVertex (FNodeBuilder::FPrivVert &vert)
 	// If a vertex is near a block boundary, then it will be inserted on
 	// both sides of the boundary so that SelectVertexClose can find
 	// it by checking in only one block.
-	fixed64_t minx = MAX (MinX, fixed64_t(vert.x) - VERTEX_EPSILON);
+	fixed64_t minx = max(MinX, fixed64_t(vert.x) - VERTEX_EPSILON);
 	fixed64_t maxx = MIN (MaxX, fixed64_t(vert.x) + VERTEX_EPSILON);
-	fixed64_t miny = MAX (MinY, fixed64_t(vert.y) - VERTEX_EPSILON);
+	fixed64_t miny = max(MinY, fixed64_t(vert.y) - VERTEX_EPSILON);
 	fixed64_t maxy = MIN (MaxY, fixed64_t(vert.y) + VERTEX_EPSILON);
 
 	int blk[4] =

source/core/palette.cpp

@@ -488,9 +488,9 @@ void DrawFullscreenBlends()
     // These get prepended to the 2D drawer so they must be submitted in reverse order of drawing.
     if (tint_blood_r | tint_blood_g | tint_blood_b)
     {
-        PalEntry color2(255, std::max(-tint_blood_r, 0), std::max(-tint_blood_g, 0), std::max(-tint_blood_b, 0));
+        PalEntry color2(255, max(-tint_blood_r, 0), max(-tint_blood_g, 0), max(-tint_blood_b, 0));
         twod->AddColorOnlyQuad(0, 0, twod->GetWidth(), twod->GetHeight(), color2, &LegacyRenderStyles[STYLE_Subtract], true);
-        PalEntry color(255, std::max(tint_blood_r, 0), std::max(tint_blood_g, 0), std::max(tint_blood_b, 0));
+        PalEntry color(255, max(tint_blood_r, 0), max(tint_blood_g, 0), max(tint_blood_b, 0));
         twod->AddColorOnlyQuad(0, 0, twod->GetWidth(), twod->GetHeight(), color, &LegacyRenderStyles[STYLE_Add], true);
     }
 

source/core/rendering/scene/hw_portal.h

@@ -96,7 +96,7 @@ struct BoundingRect
 	double distanceTo(const BoundingRect& other) const
 	{
 		if (intersects(other)) return 0;
-		return std::max(std::min(fabs(left - other.right), fabs(right - other.left)),
+		return max(std::min(fabs(left - other.right), fabs(right - other.left)),
 			std::min(fabs(top - other.bottom), fabs(bottom - other.top)));
 	}
 

source/core/rendering/scene/hw_walls.cpp

@@ -932,8 +932,8 @@ void HWWall::DoMidTexture(HWDrawInfo* di, walltype* wal,
 
 	topleft = std::min(bch1,fch1);
 	topright = std::min(bch2,fch2);
-	bottomleft = std::max(bfh1,ffh1);
+	bottomleft = max(bfh1,ffh1);
-	bottomright = std::max(bfh2,ffh2);
+	bottomright = max(bfh2,ffh2);
 	if (topleft<=bottomleft && topright<=bottomright) return;
 	type = seg->cstat & CSTAT_WALL_1WAY ? RENDERWALL_M1S : RENDERWALL_M2S;
 

source/games/duke/src/sectors.cpp

@@ -40,7 +40,6 @@ source as it is released.
 #include "interpolate.h"
 
 using std::min;
-using std::max;
 // PRIMITIVE
 BEGIN_DUKE_NS
 

source/games/exhumed/src/object.cpp

@@ -664,7 +664,7 @@ void MoveSectorSprites(int nSector, int z)
     int newz = sector[nSector].floorz;
     int oldz = newz - z;
     int minz = std::min(newz, oldz);
-    int maxz = std::max(newz, oldz);
+    int maxz = max(newz, oldz);
     ExhumedSectIterator it(nSector);
     while (auto pActor = it.Next())
     {