From 45f7e7513a86b38ca240bbc796fbf5090a26a0d9 Mon Sep 17 00:00:00 2001
From: Steven French <mr.steven.french@gmail.com>
Date: Wed, 17 Apr 2024 00:34:44 +1200
Subject: [PATCH] wrap std::numeric_limits<>::min/max in brackets

---
 glm/ext/quaternion_exponential.inl |  2 +-
 glm/ext/scalar_ulp.inl             | 10 +++++-----
 glm/gtc/packing.inl                |  8 ++++----
 glm/gtc/random.inl                 | 26 +++++++++++++-------------
 glm/gtc/ulp.inl                    | 10 +++++-----
 glm/gtx/common.inl                 |  2 +-
 glm/gtx/compatibility.inl          |  4 ++--
 glm/gtx/component_wise.inl         | 10 +++++-----
 glm/gtx/float_notmalize.inl        |  2 +-
 9 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/glm/ext/quaternion_exponential.inl b/glm/ext/quaternion_exponential.inl
index 8a9d774b..26c4ab14 100644
--- a/glm/ext/quaternion_exponential.inl
+++ b/glm/ext/quaternion_exponential.inl
@@ -60,7 +60,7 @@ namespace glm
 			//VectorMagnitude to 0. here; we could use denorm_int() compiling a
 			//project with unsafe maths optimizations might make the comparison
 			//always false, even when VectorMagnitude is 0.
-			if (VectorMagnitude < std::numeric_limits<T>::min()) {
+			if (VectorMagnitude < (std::numeric_limits<T>::min)()) {
 				//Equivalent to raising a real number to a power
 				return qua<T, Q>::wxyz(pow(x.w, y), 0, 0, 0);
 			}
diff --git a/glm/ext/scalar_ulp.inl b/glm/ext/scalar_ulp.inl
index 9858dc05..b0ed37a3 100644
--- a/glm/ext/scalar_ulp.inl
+++ b/glm/ext/scalar_ulp.inl
@@ -198,7 +198,7 @@ namespace glm
 	GLM_FUNC_QUALIFIER float nextFloat(float x)
 	{
 #		if GLM_HAS_CXX11_STL
-			return std::nextafter(x, std::numeric_limits<float>::max());
+			return std::nextafter(x, (std::numeric_limits<float>::max)());
 #		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
 			return detail::nextafterf(x, FLT_MAX);
 #		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
@@ -212,9 +212,9 @@ namespace glm
 	GLM_FUNC_QUALIFIER double nextFloat(double x)
 	{
 #		if GLM_HAS_CXX11_STL
-			return std::nextafter(x, std::numeric_limits<double>::max());
+			return std::nextafter(x, (std::numeric_limits<double>::max)());
 #		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
-			return detail::nextafter(x, std::numeric_limits<double>::max());
+			return detail::nextafter(x, (std::numeric_limits<double>::max)());
 #		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
 			return __builtin_nextafter(x, DBL_MAX);
 #		else
@@ -237,7 +237,7 @@ namespace glm
 	GLM_FUNC_QUALIFIER float prevFloat(float x)
 	{
 #		if GLM_HAS_CXX11_STL
-			return std::nextafter(x, std::numeric_limits<float>::min());
+			return std::nextafter(x, (std::numeric_limits<float>::min)());
 #		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
 			return detail::nextafterf(x, FLT_MIN);
 #		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
@@ -250,7 +250,7 @@ namespace glm
 	GLM_FUNC_QUALIFIER double prevFloat(double x)
 	{
 #		if GLM_HAS_CXX11_STL
-			return std::nextafter(x, std::numeric_limits<double>::min());
+			return std::nextafter(x, (std::numeric_limits<double>::min)());
 #		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
 			return _nextafter(x, DBL_MIN);
 #		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
diff --git a/glm/gtc/packing.inl b/glm/gtc/packing.inl
index 70f80991..e80c2b87 100644
--- a/glm/gtc/packing.inl
+++ b/glm/gtc/packing.inl
@@ -687,7 +687,7 @@ namespace detail
 		GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
 		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
 
-		return vec<L, uintType, Q>(round(clamp(v, static_cast<floatType>(0), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<uintType>::max())));
+		return vec<L, uintType, Q>(round(clamp(v, static_cast<floatType>(0), static_cast<floatType>(1)) * static_cast<floatType>((std::numeric_limits<uintType>::max)())));
 	}
 
 	template<typename floatType, length_t L, typename uintType, qualifier Q>
@@ -696,7 +696,7 @@ namespace detail
 		GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
 		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
 
-		return vec<L, floatType, Q>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<uintType>::max()));
+		return vec<L, floatType, Q>(v) * (static_cast<floatType>(1) / static_cast<floatType>((std::numeric_limits<uintType>::max)()));
 	}
 
 	template<typename intType, length_t L, typename floatType, qualifier Q>
@@ -705,7 +705,7 @@ namespace detail
 		GLM_STATIC_ASSERT(std::numeric_limits<intType>::is_integer, "uintType must be an integer type");
 		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
 
-		return vec<L, intType, Q>(round(clamp(v , static_cast<floatType>(-1), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<intType>::max())));
+		return vec<L, intType, Q>(round(clamp(v , static_cast<floatType>(-1), static_cast<floatType>(1)) * static_cast<floatType>((std::numeric_limits<intType>::max)())));
 	}
 
 	template<typename floatType, length_t L, typename intType, qualifier Q>
@@ -714,7 +714,7 @@ namespace detail
 		GLM_STATIC_ASSERT(std::numeric_limits<intType>::is_integer, "uintType must be an integer type");
 		GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");
 
-		return clamp(vec<L, floatType, Q>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<intType>::max())), static_cast<floatType>(-1), static_cast<floatType>(1));
+		return clamp(vec<L, floatType, Q>(v) * (static_cast<floatType>(1) / static_cast<floatType>((std::numeric_limits<intType>::max)())), static_cast<floatType>(-1), static_cast<floatType>(1));
 	}
 
 	GLM_FUNC_QUALIFIER uint8 packUnorm2x4(vec2 const& v)
diff --git a/glm/gtc/random.inl b/glm/gtc/random.inl
index 249ec9f9..70070176 100644
--- a/glm/gtc/random.inl
+++ b/glm/gtc/random.inl
@@ -22,7 +22,7 @@ namespace detail
 		GLM_FUNC_QUALIFIER static vec<1, uint8, P> call()
 		{
 			return vec<1, uint8, P>(
-				static_cast<uint8>(std::rand() % std::numeric_limits<uint8>::max()));
+				static_cast<uint8>(std::rand() % (std::numeric_limits<uint8>::max)()));
 		}
 	};
 
@@ -32,8 +32,8 @@ namespace detail
 		GLM_FUNC_QUALIFIER static vec<2, uint8, P> call()
 		{
 			return vec<2, uint8, P>(
-				std::rand() % std::numeric_limits<uint8>::max(),
-				std::rand() % std::numeric_limits<uint8>::max());
+				std::rand() % (std::numeric_limits<uint8>::max)(),
+				std::rand() % (std::numeric_limits<uint8>::max)());
 		}
 	};
 
@@ -43,9 +43,9 @@ namespace detail
 		GLM_FUNC_QUALIFIER static vec<3, uint8, P> call()
 		{
 			return vec<3, uint8, P>(
-				std::rand() % std::numeric_limits<uint8>::max(),
-				std::rand() % std::numeric_limits<uint8>::max(),
-				std::rand() % std::numeric_limits<uint8>::max());
+				std::rand() % (std::numeric_limits<uint8>::max)(),
+				std::rand() % (std::numeric_limits<uint8>::max)(),
+				std::rand() % (std::numeric_limits<uint8>::max)());
 		}
 	};
 
@@ -55,10 +55,10 @@ namespace detail
 		GLM_FUNC_QUALIFIER static vec<4, uint8, P> call()
 		{
 			return vec<4, uint8, P>(
-				std::rand() % std::numeric_limits<uint8>::max(),
-				std::rand() % std::numeric_limits<uint8>::max(),
-				std::rand() % std::numeric_limits<uint8>::max(),
-				std::rand() % std::numeric_limits<uint8>::max());
+				std::rand() % (std::numeric_limits<uint8>::max)(),
+				std::rand() % (std::numeric_limits<uint8>::max)(),
+				std::rand() % (std::numeric_limits<uint8>::max)(),
+				std::rand() % (std::numeric_limits<uint8>::max)());
 		}
 	};
 
@@ -178,7 +178,7 @@ namespace detail
 	{
 		GLM_FUNC_QUALIFIER static vec<L, float, Q> call(vec<L, float, Q> const& Min, vec<L, float, Q> const& Max)
 		{
-			return vec<L, float, Q>(compute_rand<L, uint32, Q>::call()) / static_cast<float>(std::numeric_limits<uint32>::max()) * (Max - Min) + Min;
+			return vec<L, float, Q>(compute_rand<L, uint32, Q>::call()) / static_cast<float>((std::numeric_limits<uint32>::max)()) * (Max - Min) + Min;
 		}
 	};
 
@@ -187,7 +187,7 @@ namespace detail
 	{
 		GLM_FUNC_QUALIFIER static vec<L, double, Q> call(vec<L, double, Q> const& Min, vec<L, double, Q> const& Max)
 		{
-			return vec<L, double, Q>(compute_rand<L, uint64, Q>::call()) / static_cast<double>(std::numeric_limits<uint64>::max()) * (Max - Min) + Min;
+			return vec<L, double, Q>(compute_rand<L, uint64, Q>::call()) / static_cast<double>((std::numeric_limits<uint64>::max)()) * (Max - Min) + Min;
 		}
 	};
 
@@ -196,7 +196,7 @@ namespace detail
 	{
 		GLM_FUNC_QUALIFIER static vec<L, long double, Q> call(vec<L, long double, Q> const& Min, vec<L, long double, Q> const& Max)
 		{
-			return vec<L, long double, Q>(compute_rand<L, uint64, Q>::call()) / static_cast<long double>(std::numeric_limits<uint64>::max()) * (Max - Min) + Min;
+			return vec<L, long double, Q>(compute_rand<L, uint64, Q>::call()) / static_cast<long double>((std::numeric_limits<uint64>::max)()) * (Max - Min) + Min;
 		}
 	};
 }//namespace detail
diff --git a/glm/gtc/ulp.inl b/glm/gtc/ulp.inl
index 836c84b4..e4641e93 100644
--- a/glm/gtc/ulp.inl
+++ b/glm/gtc/ulp.inl
@@ -8,7 +8,7 @@ namespace glm
 	GLM_FUNC_QUALIFIER float next_float(float x)
 	{
 #		if GLM_HAS_CXX11_STL
-		return std::nextafter(x, std::numeric_limits<float>::max());
+		return std::nextafter(x, (std::numeric_limits<float>::max)());
 #		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
 		return detail::nextafterf(x, FLT_MAX);
 #		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
@@ -22,9 +22,9 @@ namespace glm
 	GLM_FUNC_QUALIFIER double next_float(double x)
 	{
 #		if GLM_HAS_CXX11_STL
-		return std::nextafter(x, std::numeric_limits<double>::max());
+		return std::nextafter(x, (std::numeric_limits<double>::max)());
 #		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
-		return detail::nextafter(x, std::numeric_limits<double>::max());
+		return detail::nextafter(x, (std::numeric_limits<double>::max)());
 #		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
 		return __builtin_nextafter(x, DBL_MAX);
 #		else
@@ -47,7 +47,7 @@ namespace glm
 	GLM_FUNC_QUALIFIER float prev_float(float x)
 	{
 #		if GLM_HAS_CXX11_STL
-		return std::nextafter(x, std::numeric_limits<float>::min());
+		return std::nextafter(x, (std::numeric_limits<float>::min)());
 #		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
 		return detail::nextafterf(x, FLT_MIN);
 #		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
@@ -60,7 +60,7 @@ namespace glm
 	GLM_FUNC_QUALIFIER double prev_float(double x)
 	{
 #		if GLM_HAS_CXX11_STL
-		return std::nextafter(x, std::numeric_limits<double>::min());
+		return std::nextafter(x, (std::numeric_limits<double>::min)());
 #		elif((GLM_COMPILER & GLM_COMPILER_VC) || ((GLM_COMPILER & GLM_COMPILER_INTEL) && (GLM_PLATFORM & GLM_PLATFORM_WINDOWS)))
 		return _nextafter(x, DBL_MIN);
 #		elif(GLM_PLATFORM & GLM_PLATFORM_ANDROID)
diff --git a/glm/gtx/common.inl b/glm/gtx/common.inl
index 4575b207..90fafc85 100644
--- a/glm/gtx/common.inl
+++ b/glm/gtx/common.inl
@@ -34,7 +34,7 @@ namespace detail
 #		if GLM_HAS_CXX11_STL
 			return std::fpclassify(x) == FP_SUBNORMAL;
 #		else
-			return epsilonNotEqual(x, static_cast<T>(0), epsilon<T>()) && std::fabs(x) < std::numeric_limits<T>::min();
+			return epsilonNotEqual(x, static_cast<T>(0), epsilon<T>()) && std::fabs(x) < (std::numeric_limits<T>::min)();
 #		endif
 	}
 
diff --git a/glm/gtx/compatibility.inl b/glm/gtx/compatibility.inl
index 1d49496b..63169b96 100644
--- a/glm/gtx/compatibility.inl
+++ b/glm/gtx/compatibility.inl
@@ -15,9 +15,9 @@ namespace glm
 			return _isfinite(x) != 0;
 #		else
 			if (std::numeric_limits<genType>::is_integer || std::denorm_absent == std::numeric_limits<genType>::has_denorm)
-				return std::numeric_limits<genType>::min() <= x && std::numeric_limits<genType>::max() >= x;
+				return (std::numeric_limits<genType>::min)() <= x && (std::numeric_limits<genType>::max)() >= x;
 			else
-				return -std::numeric_limits<genType>::max() <= x && std::numeric_limits<genType>::max() >= x;
+				return -(std::numeric_limits<genType>::max)() <= x && (std::numeric_limits<genType>::max)() >= x;
 #		endif
 	}
 
diff --git a/glm/gtx/component_wise.inl b/glm/gtx/component_wise.inl
index cbbc7d41..076e0e22 100644
--- a/glm/gtx/component_wise.inl
+++ b/glm/gtx/component_wise.inl
@@ -14,8 +14,8 @@ namespace detail
 	{
 		GLM_FUNC_QUALIFIER static vec<L, floatType, Q> call(vec<L, T, Q> const& v)
 		{
-			floatType const Min = static_cast<floatType>(std::numeric_limits<T>::min());
-			floatType const Max = static_cast<floatType>(std::numeric_limits<T>::max());
+			floatType const Min = static_cast<floatType>((std::numeric_limits<T>::min)());
+			floatType const Max = static_cast<floatType>((std::numeric_limits<T>::max)());
 			return (vec<L, floatType, Q>(v) - Min) / (Max - Min) * static_cast<floatType>(2) - static_cast<floatType>(1);
 		}
 	};
@@ -25,7 +25,7 @@ namespace detail
 	{
 		GLM_FUNC_QUALIFIER static vec<L, floatType, Q> call(vec<L, T, Q> const& v)
 		{
-			return vec<L, floatType, Q>(v) / static_cast<floatType>(std::numeric_limits<T>::max());
+			return vec<L, floatType, Q>(v) / static_cast<floatType>((std::numeric_limits<T>::max)());
 		}
 	};
 
@@ -47,7 +47,7 @@ namespace detail
 	{
 		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, floatType, Q> const& v)
 		{
-			floatType const Max = static_cast<floatType>(std::numeric_limits<T>::max()) + static_cast<floatType>(0.5);
+			floatType const Max = static_cast<floatType>((std::numeric_limits<T>::max)()) + static_cast<floatType>(0.5);
 			vec<L, floatType, Q> const Scaled(v * Max);
 			vec<L, T, Q> const Result(Scaled - static_cast<floatType>(0.5));
 			return Result;
@@ -59,7 +59,7 @@ namespace detail
 	{
 		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, floatType, Q> const& v)
 		{
-			return vec<L, T, Q>(vec<L, floatType, Q>(v) * static_cast<floatType>(std::numeric_limits<T>::max()));
+			return vec<L, T, Q>(vec<L, floatType, Q>(v) * static_cast<floatType>(((std::numeric_limits<T>::max))()));
 		}
 	};
 
diff --git a/glm/gtx/float_notmalize.inl b/glm/gtx/float_notmalize.inl
index 8cdbc5aa..a2e1bfb6 100644
--- a/glm/gtx/float_notmalize.inl
+++ b/glm/gtx/float_notmalize.inl
@@ -7,7 +7,7 @@ namespace glm
 	template<length_t L, typename T, qualifier Q>
 	GLM_FUNC_QUALIFIER vec<L, float, Q> floatNormalize(vec<L, T, Q> const& v)
 	{
-		return vec<L, float, Q>(v) / static_cast<float>(std::numeric_limits<T>::max());
+		return vec<L, float, Q>(v) / static_cast<float>((std::numeric_limits<T>::max)());
 	}
 
 }//namespace glm