Add saturate() function

* Also min and max IOR.

Author: cfnptr

include/math/brdf.hpp

@@ -175,4 +175,7 @@ static float reflectanceToIOR(float reflectance) noexcept
 	return (1.0f + sqrtF0) / (1.0f - sqrtF0);
 }
 
+static const float minIOR = reflectanceToIOR(0.0f); /**< Minimal supported IOR value. */
+static const float maxIOR = reflectanceToIOR(1.0f); /**< Maximal supported IOR value. */
+
 } // namespace math::brdf

include/math/color.hpp

@@ -71,7 +71,7 @@ struct [[nodiscard]] Color
 	 * @param a alpha channel color value (transparency)
 	 */
 	constexpr Color(Color rgb, float a) noexcept : r(rgb.r), g(rgb.g), b(rgb.b), 
-		a(std::clamp(a, 0.0f, 1.0f) * 255.0f + 0.5f) { }
+		a(saturate(a) * 255.0f + 0.5f) { }
 
 	/**
 	 * @brief Creates a new sRGB color structure from the binary data.
@@ -133,7 +133,7 @@ struct [[nodiscard]] Color
 	 */
 	constexpr explicit Color(float2 normRg) noexcept
 	{
-		auto c = clamp(normRg, float2(0.0f), float2(1.0f)) * float2(255.0f) + float2(0.5f);
+		auto c = saturate(normRg) * float2(255.0f) + float2(0.5f);
 		r = (uint8)c.x, g = (uint8)c.y, b = 0; a = 255;
 	}
 	/**
@@ -142,7 +142,7 @@ struct [[nodiscard]] Color
 	 */
 	constexpr explicit Color(float3 normRgb) noexcept
 	{
-		auto c = clamp(normRgb, float3(0.0f), float3(1.0f)) * float3(255.0f) + float3(0.5f);
+		auto c = saturate(normRgb) * float3(255.0f) + float3(0.5f);
 		r = (uint8)c.x, g = (uint8)c.y, b = (uint8)c.z, a = 255;
 	}
 	/**
@@ -151,7 +151,7 @@ struct [[nodiscard]] Color
 	 */
 	constexpr explicit Color(float4 normRgba) noexcept
 	{
-		auto c = clamp(normRgba, float4(0.0f), float4(1.0f)) * float4(255.0f) + float4(0.5f);
+		auto c = saturate(normRgba) * float4(255.0f) + float4(0.5f);
 		r = (uint8)c.x, g = (uint8)c.y, b = (uint8)c.z, a = (uint8)c.w;
 	}
 	/**
@@ -160,7 +160,7 @@ struct [[nodiscard]] Color
 	 */
 	explicit Color(f32x4 normRgba) noexcept
 	{
-		auto c = fma(clamp(normRgba, f32x4::zero, f32x4::one), f32x4(255.0f), f32x4(0.5f));
+		auto c = fma(saturate(normRgba), f32x4(255.0f), f32x4(0.5f));
 		r = (uint8)c.getX(), g = (uint8)c.getY(), b = (uint8)c.getZ(), a = (uint8)c.getW();
 	}
 
@@ -205,19 +205,19 @@ struct [[nodiscard]] Color
 	/**
 	 * @brief Sets sRGB color normalizer R channel. (Red)
 	 */
-	constexpr void setNormR(float r) noexcept { this->r = std::clamp(r, 0.0f, 1.0f) * 255.0f + 0.5f; }
+	constexpr void setNormR(float r) noexcept { this->r = saturate(r) * 255.0f + 0.5f; }
 	/**
 	 * @brief Sets sRGB color normalizer G channel. (Green)
 	 */
-	constexpr void setNormG(float g) noexcept { this->g = std::clamp(g, 0.0f, 1.0f) * 255.0f + 0.5f; }
+	constexpr void setNormG(float g) noexcept { this->g = saturate(g) * 255.0f + 0.5f; }
 	/**
 	 * @brief Sets sRGB color normalizer B channel. (Blue)
 	 */
-	constexpr void setNormB(float b) noexcept { this->b = std::clamp(b, 0.0f, 1.0f) * 255.0f + 0.5f; }
+	constexpr void setNormB(float b) noexcept { this->b = saturate(b) * 255.0f + 0.5f; }
 	/**
 	 * @brief Sets sRGB color normalizer A channel. (Alpha)
 	 */
-	constexpr void setNormA(float a) noexcept { this->a = std::clamp(a, 0.0f, 1.0f) * 255.0f + 0.5f; }
+	constexpr void setNormA(float a) noexcept { this->a = saturate(a) * 255.0f + 0.5f; }
 
 	/*******************************************************************************************************************
 	 * @brief Converts sRGB color to the string. (Space separated)

include/math/common.hpp

@@ -61,6 +61,12 @@ static constexpr int32 min(int32 a, int32 b, int32 c) { return std::min(std::min
  */
 static constexpr int32 max(int32 a, int32 b, int32 c) { return std::max(std::max(a, b), c); }
 
+/**
+ * @brief Clamps float value between the 0.0f and 1.0f. (Inclusive range)
+ * @param v target float value to saturate
+ */
+static constexpr float saturate(float v) { return std::clamp(v, 0.0f, 1.0f); }
+
 /**
  * @brief Returns specified floating point value sign.
  * @param v target value

include/math/line.hpp

@@ -82,7 +82,7 @@ static f32x4 closestPoint(const Line& line, f32x4 point) noexcept
 {
 	auto a = line.start, d = line.getDirection(false);
 	auto t = dot3(point - a, d) / dot3(d, d);
-	return fma(d, f32x4(std::clamp(t, 0.0f, 1.0f)), a);
+	return fma(d, f32x4(saturate(t)), a);
 }
 /**
  * @brief Returns closest point on line to the specified one in 3D space.
@@ -95,7 +95,7 @@ static f32x4 closestPoint(const Line& line, f32x4 point, float& t) noexcept
 {
 	auto a = line.start, d = line.getDirection(false);
 	t = dot3(point - a, d) / dot3(d, d);
-	return fma(d, f32x4(std::clamp(t, 0.0f, 1.0f)), a);
+	return fma(d, f32x4(saturate(t)), a);
 }
 
 } // namespace math

include/math/simd/vector/float.hpp

@@ -841,7 +841,7 @@ static float max3(f32x4 v) noexcept
 }
 
 /**
- * @brief Clamps SIMD vector components between min and max values.
+ * @brief Clamps SIMD vector components between min and max values. (Inclusive range)
  * 
  * @param v target SIMD vector to clamp
  * @param min SIMD vector with minimum values
@@ -851,6 +851,14 @@ static f32x4 clamp(f32x4 v, f32x4 min, f32x4 max) noexcept
 {
 	return math::max(math::min(v, max), min);
 }
+/**
+ * @brief Clamps SIMD vector components between the 0.0f and 1.0f. (Inclusive range)
+ * @param v target SIMD vector to saturate
+ */
+static f32x4 saturate(f32x4 v) noexcept
+{
+	return math::max(math::min(v, f32x4::one), f32x4::zero);
+}
 
 /***********************************************************************************************************************
  * @brief Fused multiply add, calculates: mul1 * mul2 + add

include/math/vector/float.hpp

@@ -629,7 +629,7 @@ static constexpr float2 min(float2 a, float2 b, float2 c) noexcept { return min(
 static constexpr float2 max(float2 a, float2 b, float2 c) noexcept { return max(max(a, b), c); }
 
 /**
- * @brief Clamps vector components between min and max values.
+ * @brief Clamps vector components between min and max values. (Inclusive range)
  * 
  * @param v target vector to clamp
  * @param min vector with minimum values
@@ -639,6 +639,14 @@ static constexpr float2 clamp(float2 v, float2 min, float2 max) noexcept
 {
 	return float2(std::clamp(v.x, min.x, max.x), std::clamp(v.y, min.y, max.y));
 }
+/**
+ * @brief Clamps vector components between the 0.0f and 1.0f. (Inclusive range)
+ * @param v target vector to saturate
+ */
+static constexpr float2 saturate(float2 v) noexcept
+{
+	return float2(std::clamp(v.x, 0.0f, 1.0f), std::clamp(v.y, 0.0f, 1.0f));
+}
 
 /***********************************************************************************************************************
  * @brief Fused multiply add, calculates: mul1 * mul2 + add
@@ -916,7 +924,7 @@ static constexpr float3 min(float3 a, float3 b, float3 c) noexcept { return min(
 static constexpr float3 max(float3 a, float3 b, float3 c) noexcept { return max(max(a, b), c); }
 
 /**
- * @brief Clamps vector components between min and max values.
+ * @brief Clamps vector components between min and max values. (Inclusive range)
  * 
  * @param v target vector to clamp
  * @param min vector with minimum values
@@ -926,6 +934,14 @@ static constexpr float3 clamp(float3 v, float3 min, float3 max) noexcept
 {
 	return float3(std::clamp(v.x, min.x, max.x), std::clamp(v.y, min.y, max.y), std::clamp(v.z, min.z, max.z));
 }
+/**
+ * @brief Clamps vector components between the 0.0f and 1.0f. (Inclusive range)
+ * @param v target vector to saturate
+ */
+static constexpr float3 saturate(float3 v) noexcept
+{
+	return float3(std::clamp(v.x, 0.0f, 1.0f), std::clamp(v.y, 0.0f, 1.0f), std::clamp(v.z, 0.0f, 1.0f));
+}
 
 /***********************************************************************************************************************
  * @brief Fused multiply add, calculates: mul1 * mul2 + add
@@ -1225,7 +1241,7 @@ static constexpr float4 min(float4 a, float4 b, float4 c) noexcept { return min(
 static constexpr float4 max(float4 a, float4 b, float4 c) noexcept { return max(max(a, b), c); }
 
 /**
- * @brief Clamps vector components between min and max values.
+ * @brief Clamps vector components between min and max values. (Inclusive range)
  * 
  * @param v target vector to clamp
  * @param min vector with minimum values
@@ -1236,6 +1252,15 @@ static constexpr float4 clamp(float4 v, float4 min, float4 max) noexcept
 	return float4(std::clamp(v.x, min.x, max.x), std::clamp(v.y, min.y, max.y),
 		std::clamp(v.z, min.z, max.z), std::clamp(v.w, min.w, max.w));
 }
+/**
+ * @brief Clamps vector components between the 0.0f and 1.0f. (Inclusive range)
+ * @param v target vector to saturate
+ */
+static constexpr float4 saturate(float4 v) noexcept
+{
+	return float4(std::clamp(v.x, 0.0f, 1.0f), std::clamp(v.y, 0.0f, 1.0f),
+		std::clamp(v.z, 0.0f, 1.0f), std::clamp(v.w, 0.0f, 1.0f));
+}
 
 /***********************************************************************************************************************
  * @brief Fused multiply add, calculates: mul1 * mul2 + add