Adding some components.

src/dawn/display/CMakeLists.txt

@@ -0,0 +1,15 @@
+# Copyright (c) 2022 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    Color.cpp
+)
+
+# Subdirs
+# add_subdirectory(font)
+# add_subdirectory(mesh)
+# add_subdirectory(shader)

src/dawn/display/Color.cpp

@@ -0,0 +1,82 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Color.hpp"
+
+using namespace Dawn;
+
+struct Color Color::fromString(const std::string str) {
+  // Convert to lowercase
+  auto lower = stringToLowercase(str);
+  
+  if(stringIncludes(lower, "cornflower")) {
+    return COLOR_CORNFLOWER_BLUE;
+
+  } else if(stringIncludes(lower, "magenta")) {
+    return COLOR_MAGENTA;
+
+  } else if(stringIncludes(lower, "white")) {
+    return COLOR_WHITE;
+
+  } else if(stringIncludes(lower, "black")) {
+    return COLOR_BLACK;
+
+  } else if(stringIncludes(lower, "red")) {
+    return COLOR_RED;
+
+  } else if(stringIncludes(lower, "green")) {
+    return COLOR_GREEN;
+
+  } else if(stringIncludes(lower, "blue")) {
+    return COLOR_BLUE;
+    
+  } else if(stringIncludes(lower, "transparent")) {
+    return COLOR_TRANSPARENT;
+  }
+
+  // Hex code?
+  if(lower[0] == '#') {
+    // Remove the hash
+    lower = lower.substr(1);
+
+    // Convert to RGB
+    if(lower.length() == 3) {
+      // Convert to 6 digit hex
+      lower = lower[0] + lower[0] + lower[1] + lower[1] + lower[2] + lower[2];
+    }
+
+    // Convert to RGB
+    return {
+      (float_t)std::stoi(lower.substr(0, 2), nullptr, 16) / 255.0f,
+      (float_t)std::stoi(lower.substr(2, 2), nullptr, 16) / 255.0f,
+      (float_t)std::stoi(lower.substr(4, 2), nullptr, 16) / 255.0f,
+      1.0f
+    };
+  }
+
+  // Split by comma 
+  auto splitByComma = stringSplit(str, ",");
+  if(splitByComma.size() == 3) {
+    // RGB
+    return {
+      (float_t)std::stof(splitByComma[0]),
+      (float_t)std::stof(splitByComma[1]),
+      (float_t)std::stof(splitByComma[2]),
+      1.0f
+    };
+  } else if(splitByComma.size() == 4) {
+    // RGBA
+    return {
+      (float_t)std::stof(splitByComma[0]),
+      (float_t)std::stof(splitByComma[1]),
+      (float_t)std::stof(splitByComma[2]),
+      (float_t)std::stof(splitByComma[3])
+    };
+  }
+
+  // TODO: Parse other kinds of colors
+  assertUnreachable("Failed to find a color match for %s", str);
+  return {};
+}

src/dawn/display/Color.hpp

@@ -0,0 +1,89 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  struct ColorU8 {
+    uint8_t r, g, b, a;
+  };
+
+  #pragma pack(push, 4)
+  struct Color final {
+    /**
+     * Returns a color from a string.
+     * 
+     * @param str String to parse.
+     * @return Color parsed.
+     */
+    static struct Color fromString(const std::string str);
+
+    float_t r, g, b, a;
+
+    const struct Color& operator = (const struct Color &val) {
+      this->r = val.r;
+      this->g = val.g;
+      this->b = val.b;
+      this->a = val.a;
+      return *this;
+    }
+
+    struct Color operator * (const float_t &x) {
+      return {
+        r * x,
+        g * x,
+        b * x,
+        a * x
+      };
+    }
+
+    struct Color operator - (const struct Color &color) {
+      return {
+        r - color.r,
+        g - color.g,
+        b - color.b,
+        a - color.a
+      };
+    }
+
+    struct Color operator + (const struct Color &color) {
+      return {
+        r + color.r,
+        g + color.g,
+        b + color.b,
+        a + color.a
+      };
+    }
+
+    const bool_t operator == (const struct Color &other) {
+      return r == other.r && g == other.g && b == other.b && a == other.a;
+    }
+
+    operator struct ColorU8() const {
+      return {
+        (uint8_t)(r * 255),
+        (uint8_t)(g * 255),
+        (uint8_t)(b * 255),
+        (uint8_t)(a * 255)
+      };
+    }
+  };
+  #pragma pack(pop)
+
+  #define COLOR_DEF(r,g,b,a)          { r, g, b, a }
+  #define COLOR_WHITE                 COLOR_DEF(1.0f, 1.0f, 1.0f, 1.0f)
+  #define COLOR_RED                   COLOR_DEF(1.0f, 0, 0, 1.0f)
+  #define COLOR_GREEN                 COLOR_DEF(0, 1.0f, 0, 1.0f)
+  #define COLOR_BLUE                  COLOR_DEF(0, 0, 1.0f, 1.0f)
+  #define COLOR_BLACK                 COLOR_DEF(0, 0, 0, 1.0f)
+  #define COLOR_MAGENTA               COLOR_DEF(1.0f, 0, 1.0f, 1.0f)
+  #define COLOR_DARK_GREY             COLOR_DEF(0.2f, 0.2f, 0.2f, 1.0f)
+  #define COLOR_LIGHT_GREY            COLOR_DEF(0.8f, 0.8f, 0.8f, 1.0f)
+  #define COLOR_CORNFLOWER_BLUE       COLOR_DEF(0.4f, 0.6f, 0.9f, 1.0f)
+  #define COLOR_WHITE_TRANSPARENT     COLOR_DEF(1.0f, 1.0f, 1.0f, 0.0f)
+  #define COLOR_BLACK_TRANSPARENT     COLOR_DEF(0.0f, 0.0f, 0.0f, 0.0f)
+  #define COLOR_TRANSPARENT           COLOR_WHITE_TRANSPARENT
+}

src/dawn/display/RenderTarget.hpp

@@ -0,0 +1,72 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+enum RenderTargetClearFlag {
+  COLOR = 1 << 0,
+  DEPTH = 1 << 0
+};
+
+namespace Dawn {
+  class RenderTarget {
+    public:
+
+      /**
+       * Return the width of the render target.
+       * 
+       * @return The width of the render target.
+       */
+      virtual float_t getWidth() = 0;
+
+      /**
+       * Return the height of the render target.
+       * 
+       * @return The height of the render target.
+       */
+      virtual float_t getHeight() = 0;
+
+      /**
+       * Returns the scale (as in pixel density) of the render target. This is
+       * typically 1.0f, but on high DPI displays this may be 2.0f or higher.
+       * 
+       * @return The scale of the render target.
+       */
+      virtual float_t getScale() = 0;
+
+      /**
+       * Sets the clear color of the render target when the clear method for
+       * the color buffer is requested.
+       * 
+       * @param color Color to use for the clear operation.
+       */
+      virtual void setClearColor(const struct Color color) = 0;
+
+      /**
+       * Request the existing data in the render target to be cleared out. We
+       * typically assume the render target can support multiple buffer types,
+       * so you can opt to only clear certain buffer types.
+       * 
+       * @param clearFlags Flags to request what is going to be cleared.
+       */
+      virtual void clear(const flag8_t clearFlags) = 0;
+
+      /**
+       * Bind the render target for rendering to. The proceeding render requests
+       * will want to render to this render target directly. In future I may
+       * see if we can have multiple render targets bound at once to make this
+       * operation perform faster.
+       */
+      virtual void bind() = 0;
+
+      /**
+       * Destroys the render target.
+      */
+      virtual RenderTarget() {
+
+      }
+  };
+}

src/dawn/display/mesh/IMesh.hpp

@@ -97,7 +97,6 @@ namespace Dawn {
        * Cleanup a previously initiated mesh.
        */
       virtual ~IMesh() {
-        this->disposeBuffers();
       }
   };
 }