Replace min/max/clamp with versions from STL

Author: DolphinChips

src/Core/ByteStream.cpp

@@ -6,6 +6,8 @@
 #include <stdlib.h>
 #include <stdint.h>
 
+#include <algorithm>
+
 namespace Vortex {
 
 // ================================================================================================
@@ -44,7 +46,7 @@ void WriteStream::write(const void* in, int bytes)
 	}
 	else if(!is_external_buffer_)
 	{
-		capacity_ = max(capacity_ << 1, newSize);
+		capacity_ = std::max(capacity_ << 1, newSize);
 		buffer_ = (uint8_t*)realloc(buffer_, capacity_);
 		memcpy(buffer_ + current_size_, in, bytes);
 		current_size_ = newSize;

src/Core/Canvas.cpp

@@ -4,6 +4,8 @@
 
 #include <math.h>
 
+#include <algorithm>
+
 namespace Vortex {
 
 // ================================================================================================
@@ -103,13 +105,13 @@ struct GetRoundRectDist : public DistanceFunc
 
 	float Get(float px, float py) const
 	{
-		float x = min(max(px, x1 + r), x2 - r);
-		float y = min(max(py, y1 + r), y2 - r);
+		float x = std::min(std::max(px, x1 + r), x2 - r);
+		float y = std::min(std::max(py, y1 + r), y2 - r);
 		if(x == px && y == py)
 		{
-			float dx = min(x - x1, x2 - x);
-			float dy = min(y - y1, y2 - y);
-			return -min(dx, dy);
+			float dx = std::min(x - x1, x2 - x);
+			float dy = std::min(y - y1, y2 - y);
+			return -std::min(dx, dy);
 		}
 		else
 		{
@@ -143,7 +145,7 @@ struct GetPolyDist : public DistanceFunc
 		for(int i = 0, j = count - 1; i < count; j = i, ++i)
 		{
 			GetLineDist ld(x[i], y[i], x[j], y[j], 0);
-			d = min(d, ld.Get(px, py));
+			d = std::min(d, ld.Get(px, py));
 		}
 		return InsidePoly(px, py) ? -d : d;
 	}
@@ -180,13 +182,13 @@ void Canvas::Data::draw(float* buf, int w, int h, const areaf& area, DistanceFun
 	if(blendMode == Canvas::BM_ALPHA) blendfunc = BlendAlpha;
 	if(blendMode == Canvas::BM_ADD) blendfunc = BlendAdd;
 
-	int x1 = max(mask.l, (int)(area.l - outerGlow - 1 + 0.5f));
-	int y1 = max(mask.t, (int)(area.t - outerGlow - 1 + 0.5f));
-	int x2 = min(mask.r, (int)(area.r + outerGlow + 1 + 0.5f));
-	int y2 = min(mask.b, (int)(area.b + outerGlow + 1 + 0.5f));
+	int x1 = std::max(mask.l, (int)(area.l - outerGlow - 1 + 0.5f);
+	int y1 = std::max(mask.t, (int)(area.t - outerGlow - 1 + 0.5f);
+	int x2 = std::min(mask.r, (int)(area.r + outerGlow + 1 + 0.5f);
+	int y2 = std::min(mask.b, (int)(area.b + outerGlow + 1 + 0.5f);
 
-	float rh = 1.f / max(1, y2 - y1);
-	float rw = 1.f / max(1, x2 - x1);
+	float rh = 1.f / std::max(1, y2 - y1);
+	float rw = 1.f / std::max(1, x2 - x1);
 	float ig = 1.f / (innerGlow + 1);
 	float og = 1.f / (outerGlow + 1);
 
@@ -206,12 +208,12 @@ void Canvas::Data::draw(float* buf, int w, int h, const areaf& area, DistanceFun
 			if(outline && dist < -0.5f)
 			{
 				float a = 1 - ig * ((-dist - lineWidth) + 0.5f);
-				if(a > 0) blendfunc(*dst, src, min(a, 1.f));
+				if(a > 0) blendfunc(*dst, src, std::min(a, 1.f));
 			}
 			else
 			{
 				float a = 1 - og * (dist + 0.5f);
-				if(a > 0) blendfunc(*dst, src, min(a, 1.f));
+				if(a > 0) blendfunc(*dst, src, std::min(a, 1.f));
 			}
 		}
 	}
@@ -248,7 +250,7 @@ Canvas::Canvas(const Canvas& other)
 
 void Canvas::setMask(int l, int t, int r, int b)
 {
-	data_->mask = {max(0, l), max(0, t), min(r, canvas_width_), min(r, canvas_height_)};
+	data_->mask = {std::max(0, l), std::max(0, t), std::min(r, canvas_width_), std::min(r, canvas_height_)};
 }
 
 void Canvas::setOutline(float size)
@@ -312,8 +314,8 @@ void Canvas::clear(float l)
 void Canvas::line(float x1, float y1, float x2, float y2, float width)
 {
 	float r = width * 0.5f;
-	float xmin = min(x1, x2), xmax = max(x1, x2);
-	float ymin = min(y1, y2), ymax = max(y1, y2);
+	float xmin = std::min(x1, x2), xmax = std::max(x1, x2);
+	float ymin = std::min(y1, y2), ymax = std::max(y1, y2);
 	GetLineDist func(x1, y1, x2, y2, r);
 	data_->draw(canvas_data_, canvas_width_, canvas_height_, {xmin - r, ymin - r, xmax + r, ymax + r}, &func);
 }
@@ -326,9 +328,9 @@ void Canvas::circle(float x, float y, float r)
 
 void Canvas::box(float x1, float y1, float x2, float y2, float radius)
 {
-	float xl = min(x1, x2), xr = max(x1, x2);
-	float yt = min(y1, y2), yb = max(y1, y2);
-	float r = min(min(xr - xl, yb - yt)*0.5f, max(0.f, radius));
+	float xl = std::min(x1, x2), xr = std::max(x1, x2);
+	float yt = std::min(y1, y2), yb = std::max(y1, y2);
+	float r = std::min(std::min(xr - xl, yb - yt)*0.5f, std::max(0.f, radius));
 	GetRoundRectDist func(xl, yt, xr, yb, r);
 	data_->draw(canvas_data_, canvas_width_, canvas_height_, {xl, yt, xr, yb}, &func);
 }
@@ -351,7 +353,7 @@ Texture Canvas::createTexture(bool mipmap) const
 	for(int i = 0; i < canvas_width_ * canvas_height_ * 4; ++i)
 	{
 		int v = (int)(canvas_data_[i] * 255.f + 0.5f);
-		dst[i] = min(max(v, 0), 255);
+		dst[i] = std::min(std::max(v, 0), 255);
 	}
 	Texture result(canvas_width_, canvas_height_, dst, mipmap);
 	free(dst);

src/Core/Draw.cpp

@@ -3,6 +3,8 @@
 #include <Core/Utils.h>
 #include <Core/Renderer.h>
 
+#include <algorithm>
+
 namespace Vortex {
 namespace {
 
@@ -82,7 +84,7 @@ static void TB_setVerts(const TileBar& bar, int* vp, float* vt, recti r, areaf u
 	}
 
 	// Texture coordinates: left-to-right [s,t,u,v] top-to-bottom [w,x].
-	float rw = 1.0f / max(bar.texture.width(), 1);
+	float rw = 1.0f / std::max(bar.texture.width(), 1);
 	float s = uvs.l, t = uvs.l + (b - a) * rw, u = uvs.r - (d - c) * rw, v = uvs.r;
 	float w = uvs.t, x = uvs.b;
 
@@ -172,8 +174,8 @@ static void TR_setVerts(const TileRect& rect, int* vp, float* vt, recti r, areaf
 
 	// Texture coordinates: left-to-right [s,t,u,v] top-to-bottom [w,x,y,z].
 	vec2i size = rect.texture.size();
-	float rw = 1.f / max(size.x, 1);
-	float rh = 1.f / max(size.y, 1);
+	float rw = 1.f / std::max(size.x, 1);
+	float rh = 1.f / std::max(size.y, 1);
 	float s = uvs.l, t = uvs.l + (b - a) * rw, u = uvs.r - (d - c) * rw, v = uvs.r;
 	float w = uvs.t, x = uvs.t + (f - e) * rh, y = uvs.b - (h - g) * rh, z = uvs.b;
 
@@ -242,8 +244,8 @@ static void TR2_setVerts(const TileRect2& rect, int* vp, float* vt, recti r, int
 
 	// Texture coordinates: left-to-right [s,t,u,v] top-to-bottom [w,x,y,z].
 	vec2i size = rect.texture.size();
-	float rw = 1.f / max(size.x, 1);
-	float rh = 1.f / max(size.y, 1);
+	float rw = 1.f / std::max(size.x, 1);
+	float rh = 1.f / std::max(size.y, 1);
 	float s = 0, t = (b - a) * rw, u = 0.5f - (d - c) * rw, v = 0.5f;
 	float w = 0, x = (f - e) * rh, y = 1.0f - (h - g) * rh, z = 1.0f;
 

src/Core/FontData.cpp

@@ -7,6 +7,8 @@
 #include FT_FREETYPE_H
 #include FT_GLYPH_H
 
+#include <algorithm>
+
 #include <System/OpenGL.h>
 
 namespace Vortex {
@@ -217,7 +219,7 @@ static Glyph* PutGlyphInCache(GlyphCache* cache, FT_GlyphSlot slot)
 		// Copy the glyph pixels to the cache texture.
 		uint8_t* pixels = CopyGlyphBitmap(bitmapW, bitmapH, bitmap);
 		cache->tex->modify(glyph->box.x, glyph->box.y, bitmapW, bitmapH, pixels);
-		cache->shelfH = max(cache->shelfH, bitmapH);
+		cache->shelfH = std::max(cache->shelfH, bitmapH);
 		free(pixels);
 
 		// Set the glyph uvs.

src/Core/FontManager.cpp

@@ -11,6 +11,8 @@
 #include FT_LCD_FILTER_H
 #include FT_GLYPH_H
 
+#include <algorithm>
+
 namespace Vortex {
 
 namespace {
@@ -252,7 +254,7 @@ void FontManager::startFrame(float dt)
 
 const Glyph& FontManager::getPlaceholderGlyph(int size)
 {
-	int i = max(0, min(size / 8, 7));
+	int i = std::max(0, std::min(size / 8, 7));
 	return FM->placeholderGlyphs[i];
 }
 

src/Core/Gui.cpp

@@ -16,6 +16,8 @@
 
 #include <System/Debug.h>
 
+#include <algorithm>
+
 namespace Vortex {
 namespace {
 
@@ -91,7 +93,7 @@ static void handleTooltip()
 		{
 			TextStyle style;
 
-			int alpha = clamp((int)(GUI->tooltipTimer * 1000 - 1000), 0, 255);
+			int alpha = std::clamp((int)(GUI->tooltipTimer * 1000 - 1000, 0, 255);
 
 			style.textColor = Color32(0, alpha);
 			style.shadowColor = Colors::blank;
@@ -114,8 +116,8 @@ static void handleTooltip()
 				}
 			}
 
-			pos.x = clamp(pos.x, 4, GUI->viewSize.x - textSize.x - 4);
-			pos.y = clamp(pos.y, 4, GUI->viewSize.y - textSize.y - 4);
+			pos.x = std::clamp(pos.x, 4, GUI->viewSize.x - textSize.x - 4);
+			pos.y = std::clamp(pos.y, 4, GUI->viewSize.y - textSize.y - 4);
 
 			recti textBox = {pos.x, pos.y, textSize.x, textSize.y};
 			recti box = Expand(textBox, 3);

src/Core/GuiContext.cpp

@@ -4,6 +4,8 @@
 #include <Core/MapUtils.h>
 #include <Core/VectorUtils.h>
 
+#include <algorithm>
+
 namespace Vortex {
 
 GuiContext::~GuiContext()
@@ -45,8 +47,8 @@ void GuiContextImpl::tick(recti view, float deltaTime, InputEvents& events)
 {
 	view_rect_ = view;
 
-	view_rect_.w = max(view_rect_.w, 0);
-	view_rect_.h = max(view_rect_.h, 0);
+	view_rect_.w = std::max(view_rect_.w, 0);
+	view_rect_.h = std::max(view_rect_.h, 0);
 
 	delta_time_ = deltaTime;
 	input_events_ = &events;

src/Core/GuiDialog.cpp

@@ -5,6 +5,8 @@
 #include <Core/GuiContext.h>
 #include <Core/GuiWidget.h>
 
+#include <algorithm>
+
 namespace Vortex {
 
 #define MY_GUI ((GuiContextImpl*)gui_)
@@ -213,14 +215,14 @@ void DialogData::ClampRect()
 	if(current_action_ && current_action_->type >= ACT_RESIZE)
 	{
 		auto a = (ResizeAction*)current_action_;
-		if(a->dirH < 0) rect_.w = min(rect_.w, a->anchor.x - bounds.x);
-		if(a->dirH > 0) rect_.w = min(rect_.w, bounds.x + bounds.w - a->anchor.x);
-		if(a->dirV < 0) rect_.h = min(rect_.h, a->anchor.y - bounds.y);
-		if(a->dirV > 0) rect_.h = min(rect_.h, bounds.y + bounds.h - a->anchor.y);
+		if(a->dirH < 0) rect_.w = std::min(rect_.w, a->anchor.x - bounds.x);
+		if(a->dirH > 0) rect_.w = std::min(rect_.w, bounds.x + bounds.w - a->anchor.x);
+		if(a->dirV < 0) rect_.h = std::min(rect_.h, a->anchor.y - bounds.y);
+		if(a->dirV > 0) rect_.h = std::min(rect_.h, bounds.y + bounds.h - a->anchor.y);
 	}
 
-	rect_.w = max(min_size_.x, min(max_size_.x, min(bounds.w, rect_.w)));
-	rect_.h = max(min_size_.y, min(max_size_.y, min(bounds.h, rect_.h)));
+	rect_.w = std::max(min_size_.x, std::min(max_size_.x, std::min(bounds.w, rect_.w)));
+	rect_.h = std::max(min_size_.y, std::min(max_size_.y, std::min(bounds.h, rect_.h)));
 
 	if(current_action_ && current_action_->type >= ACT_RESIZE)
 	{
@@ -230,8 +232,8 @@ void DialogData::ClampRect()
 	}
 
 	int marginH = minimized_state_ ? (FRAME_PADDING * -2) : rect_.h;
-	rect_.x = max(min(rect_.x, bounds.x + bounds.w - rect_.w), bounds.x);
-	rect_.y = max(min(rect_.y, bounds.y + bounds.h - marginH), bounds.y);
+	rect_.x = std::max(std::min(rect_.x, bounds.x + bounds.w - rect_.w), bounds.x);
+	rect_.y = std::max(std::min(rect_.y, bounds.y + bounds.h - marginH), bounds.y);
 }
 
 void DialogData::arrange()
@@ -528,22 +530,22 @@ void GuiDialog::setHeight(int h)
 
 void GuiDialog::setMinimumWidth(int w)
 {
-	DATA->min_size_.x = max(0, w);
+	DATA->min_size_.x = std::max(0, w);
 }
 
 void GuiDialog::setMinimumHeight(int h)
 {
-	DATA->min_size_.y = max(0, h);
+	DATA->min_size_.y = std::max(0, h);
 }
 
 void GuiDialog::setMaximumWidth(int w)
 {
-	DATA->max_size_.x = max(0, w);
+	DATA->max_size_.x = std::max(0, w);
 }
 
 void GuiDialog::setMaximumHeight(int h)
 {
-	DATA->max_size_.y = max(0, h);
+	DATA->max_size_.y = std::max(0, h);
 }
 
 void GuiDialog::setCloseable(bool enable)

src/Core/Renderer.cpp

@@ -6,6 +6,8 @@
 #include <Core/Draw.h>
 #include <Core/Canvas.h>
 
+#include <algorithm>
+
 #include <System/Debug.h>
 #include <System/OpenGL.h>
 
@@ -206,7 +208,7 @@ void Renderer::pushScissorRect(const recti& r)
 void Renderer::pushScissorRect(int x, int y, int w, int h)
 {
 	auto& stack = RI->scissorStack;
-	w = max(w, 0), h = max(h, 0);
+	w = std::max(w, 0), h = std::max(h, 0);
 	if(stack.empty())
 	{
 		// The new scissor region is the first scissor region, use it as-is.
@@ -217,10 +219,10 @@ void Renderer::pushScissorRect(int x, int y, int w, int h)
 	{
 		// Calculate the intersection of the current and new scissor region.
 		recti last = stack.back();
-		int r = min(last.x + last.w, x + w);
-		int b = min(last.y + last.h, y + h);
-		x = max(last.x, x), w = max(0, r - x);
-		y = max(last.y, y), h = max(0, b - y);
+		int r = std::min(last.x + last.w, x + w);
+		int b = std::min(last.y + last.h, y + h);
+		x = std::max(last.x, x), w = std::max(0, r - x);
+		y = std::max(last.y, y), h = std::max(0, b - y);
 		stack.push_back({x, y, w, h});
 	}