Moved Colour constants into the Colour definitions

Author: Raelr

engine/utils/Colour.cpp

@@ -6,5 +6,14 @@
 //     https://opensource.org/licenses/Zlib
 //
 
+#include "Colour.h"
+
 namespace Siege
-{} // namespace Siege
+{
+Colour<uint8_t>::Colour(const FColour& other) :
+    r {static_cast<uint8_t>(other.r)},
+    g {static_cast<uint8_t>(other.g)},
+    b {static_cast<uint8_t>(other.b)},
+    a {static_cast<uint8_t>(other.a)}
+{}
+} // namespace Siege

engine/utils/Colour.h

@@ -19,83 +19,198 @@ namespace Siege
 template<typename T, typename std::enable_if<std::is_arithmetic<T>::value>::type* = nullptr>
 struct Colour;
 
-typedef Colour<float> FColour;
-typedef Colour<uint8_t> IColour;
+typedef struct Colour<float> FColour;
+typedef struct Colour<uint8_t> IColour;
 
-template<typename T, typename std::enable_if<std::is_arithmetic<T>::value>::type*>
-struct Colour
+/**
+ * An 8-bit unsigned integer based Colour struct. Every colour channel in this struct ranges between
+ * 0 and 255, with 255 being the brightest colour channel
+ */
+template<>
+struct Colour<uint8_t>
 {
+    // Static constants
+
+    static const IColour White;
+    static const IColour Black;
+    static const IColour Red;
+    static const IColour Green;
+    static const IColour Blue;
+    static const IColour Pink;
+
     // 'Structors
 
-    inline constexpr Colour(T red = 0, T green = 0, T blue = 0, T alpha = 0) :
+    /**
+     * The base constructor for the colour
+     * @param red the red channel value
+     * @param green the green channel value
+     * @param blue the blue channel value
+     * @param alpha the alpha channel value
+     */
+    inline constexpr Colour(uint8_t red = 0,
+                            uint8_t green = 0,
+                            uint8_t blue = 0,
+                            uint8_t alpha = 0) :
         r {red},
         g {green},
         b {blue},
         a {alpha}
     {}
 
-    inline constexpr Colour(const FColour& other) :
-        r {static_cast<T>(other.r)},
-        g {static_cast<T>(other.g)},
-        b {static_cast<T>(other.b)},
-        a {static_cast<T>(other.a)}
-    {}
+    /**
+     * A conversion from a float-based Colour struct.
+     * @warn this does not convert the normalised values of an FColour into an IColour. Please be
+     * careful with how you convert between these two. If you want a function which converts the
+     * normalised value of the FColour to a 0 - 255 range, please use the ToIColour() method
+     * @param other
+     */
+    Colour(const FColour& other);
 
+    /**
+     * A copy constructor for the IColour struct
+     * @param other the IColour to copy over
+     */
     inline constexpr Colour(const IColour& other) :
-        r {static_cast<T>(other.r)},
-        g {static_cast<T>(other.g)},
-        b {static_cast<T>(other.b)},
-        a {static_cast<T>(other.a)}
+        r {other.r},
+        g {other.g},
+        b {other.b},
+        a {other.a}
     {}
 
-    inline constexpr bool operator==(const FColour& other) const
+    /**
+     * An equality operator
+     * @param other the Colour to compare to
+     * @return true of they are the same, false if they aren't
+     */
+    inline constexpr bool operator==(const IColour& other) const
     {
         return r == other.r && g == other.g && b == other.b && a == other.a;
     }
 
-    inline constexpr bool operator==(const IColour& other) const
+    /**
+     * An in-equality operator
+     * @param other the Colour to compare to
+     * @return false of they are the same, true if they aren't
+     */
+    inline constexpr bool operator!=(const IColour& other) const
     {
-        return r == other.r && g == other.g && b == other.b && a == other.a;
+        return r == other.r || g == other.g || b == other.b || a == other.a;
     }
 
-    inline constexpr bool operator!=(const FColour& other) const
+    // Public members
+
+    uint8_t r {0};
+    uint8_t g {0};
+    uint8_t b {0};
+    uint8_t a {0};
+};
+
+inline constexpr IColour IColour::White {255, 255, 255, 255};
+inline constexpr IColour IColour::Black {0, 0, 0, 255};
+inline constexpr IColour IColour::Red {255, 0, 0, 255};
+inline constexpr IColour IColour::Green {0, 255, 0, 255};
+inline constexpr IColour IColour::Blue {0, 0, 255, 255};
+inline constexpr IColour IColour::Pink {255, 109, 194, 255};
+
+template<>
+struct Colour<float>
+{
+    // Static constants
+
+    static const FColour White;
+    static const FColour Black;
+    static const FColour Red;
+    static const FColour Green;
+    static const FColour Blue;
+    static const FColour Pink;
+
+    /**
+     * The base constructor for the colour
+     * @param red the red channel value
+     * @param green the green channel value
+     * @param blue the blue channel value
+     * @param alpha the alpha channel value
+     */
+    inline constexpr Colour(float red = 0.f,
+                            float green = 0.f,
+                            float blue = 0.f,
+                            float alpha = 0.f) :
+        r {red},
+        g {green},
+        b {blue},
+        a {alpha}
+    {}
+
+    /**
+     * A copy constructor for the FColour struct
+     * @param other the FColour to copy over
+     */
+    inline constexpr Colour(const FColour& other) :
+        r {other.r},
+        g {other.g},
+        b {other.b},
+        a {other.a}
+    {}
+
+    /**
+     * A conversion from an 8-bit unsigned integer based Colour struct.
+     * @warn this does not convert the normalised values of an FColour into an IColour. Please be
+     * careful with how you convert between these two. If you want a function which converts the
+     * normalised value of the FColour to a 0 - 255 range, please use the ToFColour() method
+     * @param other
+     */
+    inline constexpr Colour(const IColour& other) :
+        r {static_cast<float>(other.r)},
+        g {static_cast<float>(other.g)},
+        b {static_cast<float>(other.b)},
+        a {static_cast<float>(other.a)}
+    {}
+
+    /**
+     * An equality operator
+     * @param other the Colour to compare to
+     * @return true of they are the same, false if they aren't
+     */
+    inline constexpr bool operator==(const FColour& other) const
     {
-        return r == other.r || g == other.g || b == other.b || a == other.a;
+        return r == other.r && g == other.g && b == other.b && a == other.a;
     }
 
-    inline constexpr bool operator!=(const IColour& other) const
+    /**
+     * An in-equality operator
+     * @param other the Colour to compare to
+     * @return false of they are the same, true if they aren't
+     */
+    inline constexpr bool operator!=(const FColour& other) const
     {
         return r == other.r || g == other.g || b == other.b || a == other.a;
     }
 
-    // Public members
-
-    T r {0};
-    T g {0};
-    T b {0};
-    T a {0};
+    float r {0.f};
+    float g {0.f};
+    float b {0.f};
+    float a {0.f};
 };
 
 // FColour constants
 
-inline constexpr FColour FWhite = {1.f, 1.f, 1.f, 1.f};
-inline constexpr FColour FBlack = {0.f, 0.f, 0.f, 1.f};
-inline constexpr FColour FRed = {1.f, 0.f, 0.f, 1.f};
-inline constexpr FColour FGreen = {0.f, 1.f, 0.f, 1.f};
-inline constexpr FColour FBlue = {0.f, 0.f, 1.f, 1.f};
-inline constexpr FColour FPink = {1.f, 0.427450980392, 0.760784313725, 1.f};
-
-// IColour constants
-
-inline constexpr IColour IWhite = {255, 255, 255, 255};
-inline constexpr IColour IBlack = {0, 0, 0, 255};
-inline constexpr IColour IRed = {255, 0, 0, 255};
-inline constexpr IColour IGreen = {0, 255, 0, 255};
-inline constexpr IColour IBlue = {0, 0, 255, 255};
-inline constexpr IColour IPink = {255, 109, 194, 255};
+inline constexpr FColour FColour::White = {1.f, 1.f, 1.f, 1.f};
+inline constexpr FColour FColour::Black = {0.f, 0.f, 0.f, 1.f};
+inline constexpr FColour FColour::Red = {1.f, 0.f, 0.f, 1.f};
+inline constexpr FColour FColour::Green = {0.f, 1.f, 0.f, 1.f};
+inline constexpr FColour FColour::Blue = {0.f, 0.f, 1.f, 1.f};
+inline constexpr FColour FColour::Pink = {1.f, 0.427450980392, 0.760784313725, 1.f};
 
 // Conversion functions
 
+/**
+ * Converts an IColour to an FColour. This function is different to the standard constructors in
+ * that it takes the 0 to 255 range of the IColour and normalises it between 0 and 1 (as a float).
+ * This Method is useful for converting 8 bit Colours to float colours in an accurate manner. This
+ * is the recommended approach for converting the two colours
+ * @param other the IColour to compare
+ * @return an FColour with the normalised values
+ */
 inline constexpr FColour ToFColour(const IColour& other)
 {
     return {(static_cast<float>(other.r) - 0.f) / (255.f - 0.f),
@@ -104,6 +219,14 @@ inline constexpr FColour ToFColour(const IColour& other)
             (static_cast<float>(other.a) - 0.f) / (255.f - 0.f)};
 }
 
+/**
+ * Converts an FColour to an IColour. This function is different to the standard constructors in
+ * that it takes the 0 to 1 range of the FColour and expands it between 0 and 255 (as a uint8_t).
+ * This Method is useful for converting 8 bit Colours to float colours in an accurate manner. This
+ * is the recommended approach for converting the two colours
+ * @param other the FColour to convert
+ * @return an IColour with the expanded values
+ */
 inline constexpr FColour ToIColour(const FColour& other)
 {
     return {static_cast<float>(other.r * 255),
@@ -117,7 +240,7 @@ inline constexpr FColour ToIColour(const FColour& other)
 namespace std
 {
 template<>
-struct ::std::hash<Siege::FColour>
+struct hash<Siege::FColour>
 {
     size_t operator()(const Siege::FColour& colour) const
     {
@@ -128,7 +251,7 @@ struct ::std::hash<Siege::FColour>
 };
 
 template<>
-struct ::std::hash<Siege::IColour>
+struct hash<Siege::IColour>
 {
     size_t operator()(const Siege::IColour& colour) const
     {

examples/game/src/tools/DevConsole.cpp

@@ -152,8 +152,8 @@ void DevConsole::OnDraw2D()
     Siege::Window* window = ServiceLocator::GetWindow();
 
     // Draw the console to the screen
-    Siege::Statics::Render().DrawRectangle2D(0, 0, window->GetWidth(), 40, Siege::IBlack);
-    Siege::Statics::Render().DrawText2D("~ " + inputText, 10.f, 10.f, 20.f, Siege::IWhite);
+    Siege::Statics::Render().DrawRectangle2D(0, 0, window->GetWidth(), 40, Siege::IColour::Black);
+    Siege::Statics::Render().DrawText2D("~ " + inputText, 10.f, 10.f, 20.f, Siege::IColour::White);
 }
 
 bool DevConsole::CheckEditorMode()

examples/game/src/tools/EditorController.cpp

@@ -189,19 +189,19 @@ void EditorController::OnDraw2D()
         (int) screenPosition.x - Siege::Window::GetTextWidth(nameLabel, 20) / 2,
         (int) screenPosition.y,
         20,
-        Siege::IPink);
+        Siege::IColour::Pink);
     Siege::Statics::Render().DrawText2D(
         posLabel,
         (int) screenPosition.x - Siege::Window::GetTextWidth(posLabel, 18) / 2,
         (int) screenPosition.y + 20,
         18,
-        currentMode == POSITION ? BRIGHT_PINK : Siege::IPink);
+        currentMode == POSITION ? BRIGHT_PINK : Siege::IColour::Pink);
     Siege::Statics::Render().DrawText2D(
         rotLabel,
         (int) screenPosition.x - Siege::Window::GetTextWidth(posLabel, 18) / 2,
         (int) screenPosition.y + 40,
         18,
-        currentMode == ROTATION ? BRIGHT_PINK : Siege::IPink);
+        currentMode == ROTATION ? BRIGHT_PINK : Siege::IColour::Pink);
 }
 
 void EditorController::SelectEntity(Entity* entity)

examples/game/src/tools/MessageDisplay.cpp

@@ -16,7 +16,7 @@ void MessageDisplay::OnDraw2D()
     // Draw the display message to the screen while the display time is valid
     if (displayTime > 0.f)
     {
-        Siege::Statics::Render().DrawText2D(displayMessage, 10, 10, 20, Siege::IPink);
+        Siege::Statics::Render().DrawText2D(displayMessage, 10, 10, 20, Siege::IColour::Pink);
         displayTime -= 0.1f;
     }
 }