Added HSV to RGB color, fixed HSV to Linear color, other fixes & added imgui type conversions

Author: muit

Include/Misc/PipeImGui.h

@@ -17,10 +17,42 @@ static_assert(false, "Imgui v" IMGUI_VERSION " found but PipeImGui requires v1.9
 #include <imgui.h>
 
 
+namespace p
+{
+	///////////////////////////////////////////////////////////
+	// Conversions
+
+	inline ImVec2 ToIM(v2 value)
+	{
+		return {value.x, value.y};
+	}
+	inline v2 FromIM(ImVec2 value)
+	{
+		return {value.x, value.y};
+	}
+	inline ImVec4 ToIM(const v4& value)
+	{
+		return {value.x, value.y, value.z, value.w};
+	}
+	inline v4 FromIMVector(const ImVec4& value)
+	{
+		return {value.x, value.y, value.z, value.w};
+	}
+	inline ImVec4 ToIM(const LinearColor& value)
+	{
+		return {value.r, value.g, value.b, value.a};
+	}
+	inline LinearColor FromIM(const ImVec4& value)
+	{
+		return {value.x, value.y, value.z, value.w};
+	}
+};
+
+
 namespace ImGui
 {
 	///////////////////////////////////////////////////////////
-	// Definition
+	// Internals
 
 	namespace details
 	{
@@ -56,7 +88,7 @@ namespace ImGui
 
 
 	///////////////////////////////////////////////////////////
-	// Definition
+	// Definitions
 
 	inline void PushID(p::StringView id)
 	{

Include/PipeColor.h

@@ -206,12 +206,22 @@ namespace p
 			}
 			else if constexpr (to == ColorMode::Linear && from == ColorMode::HSV)
 			{
-				const float hDiv60         = this->h / 60.0f;
+				float hue = Mod(this->h, 360.f);
+				if ( hue < 0.f ) hue += 360.f;
+				const float saturation = p::Clamp(this->s,0.f,1.f);
+				const float value = this->v;
+
+				const float hDiv60         = hue / 60.0f;
 				const float hDiv60Floor    = Floor(hDiv60);
 				const float hDiv60Fraction = hDiv60 - hDiv60Floor;
-
 				const u32 swizzleIndex = u32(hDiv60Floor) % 6;
 
+				const float rgbValues[4] = {
+					value,
+					value * (1.0f - saturation),
+					value * (1.0f - (hDiv60Fraction * saturation)),
+					value * (1.0f - ((1.0f - hDiv60Fraction) * saturation)),
+				};
 				constexpr u32 rgbSwizzle[6][3] = {
 				    {0, 3, 1},
                     {2, 0, 1},
@@ -220,20 +230,20 @@ namespace p
                     {3, 1, 0},
                     {0, 1, 2}
                 };
-				const float rgbValues[4] = {
-				    this->v,
-				    this->v * (1.0f - this->h),
-				    this->v * (1.0f - (hDiv60Fraction * this->h)),
-				    this->v * (1.0f - ((1.0f - hDiv60Fraction) * this->h)),
-				};
-				return {rgbValues[rgbSwizzle[swizzleIndex][0]],
-				    rgbValues[rgbSwizzle[swizzleIndex][1]], rgbValues[rgbSwizzle[swizzleIndex][2]],
+				return {
+					rgbValues[rgbSwizzle[swizzleIndex][0]],
+				    rgbValues[rgbSwizzle[swizzleIndex][1]],
+					rgbValues[rgbSwizzle[swizzleIndex][2]],
 				    this->a};
 			}
 			else if constexpr (to == ColorMode::RGBA && from == ColorMode::HSV)
 			{
 				return Convert<ColorMode::Linear>().template Convert<to>();
 			}
+			else if constexpr (to == ColorMode::HSV && from == ColorMode::RGBA)
+			{
+				return Convert<ColorMode::Linear>().template Convert<to>();
+			}
 			else
 			{
 				P_CheckMsg(false, "Not supported color conversion");
@@ -409,7 +419,10 @@ namespace p
 				P_CheckMsg(false, "operator*(scalar) is not allowed on HSV");
 				return {};
 			}
-			return {this->r * scalar, this->g * scalar, this->b * scalar, this->a * scalar};
+			else
+			{
+				return {this->r * scalar, this->g * scalar, this->b * scalar, this->a * scalar};
+			}
 		}
 		constexpr TColor& operator*=(float scalar)
 		{

Include/PipeMath.h

@@ -36,6 +36,68 @@ namespace p
 		return a <= b ? a : b;
 	}
 
+	template<typename Type>
+	static constexpr Type* Max(Type* values, u32 count)
+	{
+		if (!values || count <= 0)
+		{
+			return nullptr;
+		}
+		Type* max = values;
+		for (u32 i = 1; i < count; ++i)
+		{
+			Type* v = values + i;
+			if (*v > *max)
+			{
+				max = v;
+			}
+		}
+		return max;
+	}
+
+	template<typename Type>
+	static constexpr Type* Min(Type* values, u32 count)
+	{
+		if (!values || count <= 0)
+		{
+			return nullptr;
+		}
+		Type* min = values;
+		for (u32 i = 1; i < count; ++i)
+		{
+			Type* v = values + i;
+			if (*v < *min)
+			{
+				min = v;
+			}
+		}
+		return min;
+	}
+
+	template<typename Type>
+	static constexpr std::pair<Type*, Type*> MinMax(Type* values, u32 count)
+	{
+		if (!values || count <= 0)
+		{
+			return {nullptr, nullptr};
+		}
+		Type* min = values;
+		Type* max = values;
+		for (u32 i = 1; i < count; ++i)
+		{
+			Type* v = values + i;
+			if (*v < *min)
+			{
+				min = v;
+			}
+			if (*v > *max)
+			{
+				max = v;
+			}
+		}
+		return {min, max};
+	}
+
 	template<typename Type>
 	static constexpr Type Clamp(Type a, Type min, Type max)
 	{
@@ -372,10 +434,21 @@ namespace p
 	}
 
 	template<FloatingPoint Type>
-	static constexpr float Mod(Type a, Type b)
+	static inline constexpr float Mod(Type a, Type b)
 	{
-		return a - b * Floor(a / b);
-	}
+		if constexpr(IsSame<Type, float>)
+		{
+			return fmodf(a, b);
+		}
+		else if constexpr(IsSame<Type, double>)
+		{
+			return fmod(a, b);
+		}
+		else
+		{
+			return a - b * Floor(a / b);
+		}
+		}
 
 	template<SignedIntegral Type>
 	static constexpr Type Mod(Type a, Type b)