Move to c++ 20 and add colors

Author: ChillerDragon

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.12...3.27.4)
 
 project(twbl)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED On)
 
 option(TWBL_DEBUG "activate bot debug comments" OFF)
@@ -43,7 +43,7 @@ FILE(GLOB BOT_SOURCE_FILES
 set(TWBL_DEPS ${CMAKE_DL_LIBS})
 
 add_library(twbl STATIC ${BOT_SOURCE_FILES})
-target_compile_options(twbl PRIVATE -std=gnu++17)
+target_compile_options(twbl PRIVATE -std=gnu++20)
 add_compiler_flag_if_supported(-Wno-format-truncation)
 target_link_libraries(twbl ${TWBL_DEPS})
 include_directories(src)
@@ -74,7 +74,7 @@ endif()
 
 add_executable(twbl_probe ${BOT_SOURCE_FILES} src/tools/twbl_probe.cpp)
 target_link_libraries(twbl_probe ${TWBL_DEPS} ${LINK_FLAGS_PLATFORM})
-target_compile_options(twbl_probe PRIVATE -std=gnu++17)
+target_compile_options(twbl_probe PRIVATE -std=gnu++20)
 
 # tests
 
@@ -89,7 +89,7 @@ function(register_test test_name)
     set(test_target "test_${test_name}")
     add_executable(${test_target} ${TEST_SOURCE_FILES})
     target_link_libraries(${test_target} twbl ${TWBL_DEPS} ${LINK_FLAGS_PLATFORM})
-    target_compile_options(${test_target} PRIVATE -std=gnu++17)
+    target_compile_options(${test_target} PRIVATE -std=gnu++20)
     add_test(NAME ${test_target}
              COMMAND ${test_target})
 endfunction()

src/twbl/teeworlds/base/color.cpp

@@ -0,0 +1,48 @@
+#include <twbl/teeworlds/base/color.h>
+#include <twbl/teeworlds/base/system.h>
+
+template<typename T>
+std::optional<T> color_parse(const char *pStr)
+{
+	if(!str_isallnum_hex(pStr))
+		return {};
+
+	const unsigned Num = str_toulong_base(pStr, 16);
+
+	T Color;
+	switch(str_length(pStr))
+	{
+	case 3:
+		Color.x = (((Num >> 8) & 0x0F) + ((Num >> 4) & 0xF0)) / 255.0f;
+		Color.y = (((Num >> 4) & 0x0F) + ((Num >> 0) & 0xF0)) / 255.0f;
+		Color.z = (((Num >> 0) & 0x0F) + ((Num << 4) & 0xF0)) / 255.0f;
+		Color.a = 1.0f;
+		return Color;
+
+	case 4:
+		Color.x = (((Num >> 12) & 0x0F) + ((Num >> 8) & 0xF0)) / 255.0f;
+		Color.y = (((Num >> 8) & 0x0F) + ((Num >> 4) & 0xF0)) / 255.0f;
+		Color.z = (((Num >> 4) & 0x0F) + ((Num >> 0) & 0xF0)) / 255.0f;
+		Color.a = (((Num >> 0) & 0x0F) + ((Num << 4) & 0xF0)) / 255.0f;
+		return Color;
+
+	case 6:
+		Color.x = ((Num >> 16) & 0xFF) / 255.0f;
+		Color.y = ((Num >> 8) & 0xFF) / 255.0f;
+		Color.z = ((Num >> 0) & 0xFF) / 255.0f;
+		Color.a = 1.0f;
+		return Color;
+
+	case 8:
+		Color.x = ((Num >> 24) & 0xFF) / 255.0f;
+		Color.y = ((Num >> 16) & 0xFF) / 255.0f;
+		Color.z = ((Num >> 8) & 0xFF) / 255.0f;
+		Color.a = ((Num >> 0) & 0xFF) / 255.0f;
+		return Color;
+
+	default:
+		return {};
+	}
+}
+
+template std::optional<ColorRGBA> color_parse<ColorRGBA>(const char *);

src/twbl/teeworlds/base/color.h

@@ -0,0 +1,314 @@
+#ifndef TWBL_SRC_SHARED_COLOR_H
+#define TWBL_SRC_SHARED_COLOR_H
+
+#if __has_include(<base/color.h>)
+#include <base/color.h>
+#else
+
+#include <twbl/teeworlds/base/math.h>
+
+#include <optional>
+#include <type_traits>
+
+/*
+	Title: Color handling
+*/
+/*
+	Function: RgbToHue
+		Determines the hue from RGB values
+*/
+constexpr float RgbToHue(float r, float g, float b)
+{
+	float h_min = minimum(r, g, b);
+	float h_max = maximum(r, g, b);
+
+	float hue = 0.0f;
+	if(h_max != h_min)
+	{
+		float c = h_max - h_min;
+		if(h_max == r)
+			hue = (g - b) / c + (g < b ? 6 : 0);
+		else if(h_max == g)
+			hue = (b - r) / c + 2;
+		else
+			hue = (r - g) / c + 4;
+	}
+
+	return hue / 6.0f;
+}
+
+// Curiously Recurring Template Pattern for type safety
+template<typename DerivedT>
+class color4_base
+{
+public:
+	union
+	{
+		float x, r, h;
+	};
+	union
+	{
+		float y, g, s;
+	};
+	union
+	{
+		float z, b, l, v;
+	};
+	union
+	{
+		float w, a;
+	};
+
+	constexpr color4_base() :
+		x(), y(), z(), a()
+	{
+	}
+
+	constexpr color4_base(float nx, float ny, float nz, float na) :
+		x(nx), y(ny), z(nz), a(na)
+	{
+	}
+
+	constexpr color4_base(float nx, float ny, float nz) :
+		x(nx), y(ny), z(nz), a(1.0f)
+	{
+	}
+
+	constexpr color4_base(unsigned col, bool alpha = false)
+	{
+		a = alpha ? ((col >> 24) & 0xFF) / 255.0f : 1.0f;
+		x = ((col >> 16) & 0xFF) / 255.0f;
+		y = ((col >> 8) & 0xFF) / 255.0f;
+		z = ((col >> 0) & 0xFF) / 255.0f;
+	}
+
+	// Disallow casting between different instantiations of the color4_base template.
+	// The color_cast functions below should be used to convert between colors.
+	template<typename OtherDerivedT>
+	requires(!std::is_same_v<DerivedT, OtherDerivedT>)
+		color4_base(const color4_base<OtherDerivedT> &Other) = delete;
+
+	constexpr float &operator[](int index)
+	{
+		return ((float *)this)[index];
+	}
+
+	constexpr bool operator==(const color4_base &col) const { return x == col.x && y == col.y && z == col.z && a == col.a; }
+	constexpr bool operator!=(const color4_base &col) const { return x != col.x || y != col.y || z != col.z || a != col.a; }
+
+	constexpr unsigned Pack(bool Alpha = true) const
+	{
+		return (Alpha ? ((unsigned)round_to_int(a * 255.0f) << 24) : 0) + ((unsigned)round_to_int(x * 255.0f) << 16) + ((unsigned)round_to_int(y * 255.0f) << 8) + (unsigned)round_to_int(z * 255.0f);
+	}
+
+	constexpr unsigned PackAlphaLast(bool Alpha = true) const
+	{
+		if(Alpha)
+			return ((unsigned)round_to_int(x * 255.0f) << 24) + ((unsigned)round_to_int(y * 255.0f) << 16) + ((unsigned)round_to_int(z * 255.0f) << 8) + (unsigned)round_to_int(a * 255.0f);
+		return ((unsigned)round_to_int(x * 255.0f) << 16) + ((unsigned)round_to_int(y * 255.0f) << 8) + (unsigned)round_to_int(z * 255.0f);
+	}
+
+	constexpr DerivedT WithAlpha(float alpha) const
+	{
+		DerivedT col(static_cast<const DerivedT &>(*this));
+		col.a = alpha;
+		return col;
+	}
+
+	constexpr DerivedT WithMultipliedAlpha(float alpha) const
+	{
+		DerivedT col(static_cast<const DerivedT &>(*this));
+		col.a *= alpha;
+		return col;
+	}
+
+	template<typename UnpackT>
+	constexpr static UnpackT UnpackAlphaLast(unsigned Color, bool Alpha = true)
+	{
+		UnpackT Result;
+		if(Alpha)
+		{
+			Result.x = ((Color >> 24) & 0xFF) / 255.0f;
+			Result.y = ((Color >> 16) & 0xFF) / 255.0f;
+			Result.z = ((Color >> 8) & 0xFF) / 255.0f;
+			Result.a = ((Color >> 0) & 0xFF) / 255.0f;
+		}
+		else
+		{
+			Result.x = ((Color >> 16) & 0xFF) / 255.0f;
+			Result.y = ((Color >> 8) & 0xFF) / 255.0f;
+			Result.z = ((Color >> 0) & 0xFF) / 255.0f;
+			Result.a = 1.0f;
+		}
+		return Result;
+	}
+};
+
+class ColorHSLA : public color4_base<ColorHSLA>
+{
+public:
+	using color4_base::color4_base;
+	constexpr ColorHSLA() = default;
+
+	constexpr static const float DARKEST_LGT = 0.5f;
+	constexpr static const float DARKEST_LGT7 = 61.0f / 255.0f;
+
+	constexpr ColorHSLA UnclampLighting(float Darkest) const
+	{
+		ColorHSLA col = *this;
+		col.l = Darkest + col.l * (1.0f - Darkest);
+		return col;
+	}
+
+	constexpr unsigned Pack(bool Alpha = true) const
+	{
+		return color4_base::Pack(Alpha);
+	}
+
+	constexpr unsigned Pack(float Darkest, bool Alpha = false) const
+	{
+		ColorHSLA col = *this;
+		col.l = (l - Darkest) / (1 - Darkest);
+		col.l = std::clamp(col.l, 0.0f, 1.0f);
+		return col.Pack(Alpha);
+	}
+};
+
+class ColorHSVA : public color4_base<ColorHSVA>
+{
+public:
+	using color4_base::color4_base;
+	constexpr ColorHSVA() = default;
+};
+
+class ColorRGBA : public color4_base<ColorRGBA>
+{
+public:
+	using color4_base::color4_base;
+	constexpr ColorRGBA() = default;
+
+	constexpr ColorRGBA Multiply(const ColorRGBA &Other) const
+	{
+		ColorRGBA Color = *this;
+		Color.r *= Other.r;
+		Color.g *= Other.g;
+		Color.b *= Other.b;
+		Color.a *= Other.a;
+		return Color;
+	}
+
+	template<Numeric T>
+	constexpr ColorRGBA Multiply(const T &Factor) const
+	{
+		ColorRGBA Color = *this;
+		Color.r *= Factor;
+		Color.g *= Factor;
+		Color.b *= Factor;
+		Color.a *= Factor;
+		return Color;
+	}
+};
+
+template<typename T, typename F>
+constexpr T color_cast(const F &) = delete;
+
+template<>
+constexpr ColorHSLA color_cast(const ColorRGBA &rgb)
+{
+	float Min = minimum(rgb.r, rgb.g, rgb.b);
+	float Max = maximum(rgb.r, rgb.g, rgb.b);
+
+	float c = Max - Min;
+	float h = RgbToHue(rgb.r, rgb.g, rgb.b);
+	float l = 0.5f * (Max + Min);
+	float s = (Max != 0.0f && Min != 1.0f) ? (c / (1 - (absolute(2 * l - 1)))) : 0;
+
+	return ColorHSLA(h, s, l, rgb.a);
+}
+
+template<>
+constexpr ColorRGBA color_cast(const ColorHSLA &hsl)
+{
+	float h1 = hsl.h * 6;
+	float c = (1.f - absolute(2 * hsl.l - 1)) * hsl.s;
+	float x = c * (1.f - absolute(std::fmod(h1, 2) - 1.f));
+
+	float r = 0.0f;
+	float g = 0.0f;
+	float b = 0.0f;
+	switch(round_truncate(h1))
+	{
+	case 0:
+		r = c;
+		g = x;
+		break;
+	case 1:
+		r = x;
+		g = c;
+		break;
+	case 2:
+		g = c;
+		b = x;
+		break;
+	case 3:
+		g = x;
+		b = c;
+		break;
+	case 4:
+		r = x;
+		b = c;
+		break;
+	case 5:
+	case 6:
+		r = c;
+		b = x;
+		break;
+	}
+
+	float m = hsl.l - (c / 2);
+	return ColorRGBA(r + m, g + m, b + m, hsl.a);
+}
+
+template<>
+constexpr ColorHSLA color_cast(const ColorHSVA &hsv)
+{
+	float l = hsv.v * (1 - hsv.s * 0.5f);
+	return ColorHSLA(hsv.h, (l == 0.0f || l == 1.0f) ? 0 : (hsv.v - l) / minimum(l, 1 - l), l, hsv.a);
+}
+
+template<>
+constexpr ColorHSVA color_cast(const ColorHSLA &hsl)
+{
+	float v = hsl.l + hsl.s * minimum(hsl.l, 1 - hsl.l);
+	return ColorHSVA(hsl.h, v == 0.0f ? 0 : 2 - (2 * hsl.l / v), v, hsl.a);
+}
+
+template<>
+constexpr ColorRGBA color_cast(const ColorHSVA &hsv)
+{
+	return color_cast<ColorRGBA>(color_cast<ColorHSLA>(hsv));
+}
+
+template<>
+constexpr ColorHSVA color_cast(const ColorRGBA &rgb)
+{
+	return color_cast<ColorHSVA>(color_cast<ColorHSLA>(rgb));
+}
+
+template<typename T>
+constexpr T color_scale(const T &col, float s)
+{
+	return T(col.x * s, col.y * s, col.z * s, col.a * s);
+}
+
+template<typename T>
+constexpr T color_invert(const T &col)
+{
+	return T(1.0f - col.x, 1.0f - col.y, 1.0f - col.z, 1.0f - col.a);
+}
+
+template<typename T>
+std::optional<T> color_parse(const char *pStr);
+
+#endif
+#endif