Prepping to allow textures to have different render modes/types. Prepping for freetype support

src/dawn/CMakeLists.txt

@@ -8,6 +8,7 @@ target_link_libraries(${DAWN_TARGET_NAME}
   PUBLIC
     glm
     stb
+    freetype
 )
 
 # Includes

src/dawn/asset/assets/TextureAsset.cpp

@@ -20,8 +20,16 @@ void TextureAsset::updateSync() {
   ) return;
 
   this->state = 0x04;
-  this->texture.setSize(this->width, this->height);
+
+  
+  this->texture.setSize(this->width, this->height, this->format);
   this->texture.buffer(this->colors);
+  
+  this->texture.wrapModeX = this->wrapModeX;
+  this->texture.wrapModeY = this->wrapModeY;
+  this->texture.filterModeMin = this->filterModeMin;
+  this->texture.filterModeMag = this->filterModeMag;
+
   this->state = 0x05;
   this->loaded = true;
 }
@@ -33,24 +41,83 @@ void TextureAsset::updateAsync() {
   this->state = 0x02;
 
   // Parse header data.
-  char integer[32];
+  char integer[256];
   size_t j = 0, i = 0;
+  enum TextureAssetHeaderParseState parseState = TEXTURE_ASSET_HEADER_PARSE_STATE_VERSION;
   while(true) {
+    if(parseState == TEXTURE_ASSET_HEADER_PARSE_STATE_END) break;
+    
     auto c = this->buffer[i++];
-    if(c == '|') {
-      integer[j] = '\0';
-      if(this->width == -1) {
+    if(c != '|') {
+      integer[j++] = c;
+      continue;
+    }
+    
+    integer[j] = '\0';
+
+    switch(parseState) {
+      case TEXTURE_ASSET_HEADER_PARSE_STATE_VERSION: {
+        auto compared = strcmp(integer, "DT_1.00");
+        assertTrue(compared == 0);
+        j = 0;
+        parseState = TEXTURE_ASSET_HEADER_PARSE_STATE_WIDTH;
+        break;
+      }
+
+      case TEXTURE_ASSET_HEADER_PARSE_STATE_WIDTH: {
         this->width = atoi(integer);
         assertTrue(this->width > 0);
         j = 0;
-        continue;
-      } else {
-        this->height = atoi(integer);
-        assertTrue(this->height > 0);
+        parseState = TEXTURE_ASSET_HEADER_PARSE_STATE_HEIGHT;
         break;
       }
+
+      case TEXTURE_ASSET_HEADER_PARSE_STATE_HEIGHT: {
+        this->height = atoi(integer);
+        assertTrue(this->height > 0);
+        j = 0;
+        parseState = TEXTURE_ASSET_HEADER_PARSE_STATE_FORMAT;
+        break;
+      }
+
+      case TEXTURE_ASSET_HEADER_PARSE_STATE_FORMAT: {
+        this->format = (enum TextureFormat)atoi(integer);
+        j = 0;
+        parseState = TEXTURE_ASSET_HEADER_PARSE_STATE_WRAP_MODE_X;
+        break;
+      }
+
+      case TEXTURE_ASSET_HEADER_PARSE_STATE_WRAP_MODE_X: {
+        this->wrapModeX = (enum TextureWrapMode)atoi(integer);
+        j = 0;
+        parseState = TEXTURE_ASSET_HEADER_PARSE_STATE_WRAP_MODE_Y;
+        break;
+      }
+
+      case TEXTURE_ASSET_HEADER_PARSE_STATE_WRAP_MODE_Y: {
+        this->wrapModeY = (enum TextureWrapMode)atoi(integer);
+        j = 0;
+        parseState = TEXTURE_ASSET_HEADER_PARSE_STATE_FILTER_MODE_MIN;
+        break;
+      }
+
+      case TEXTURE_ASSET_HEADER_PARSE_STATE_FILTER_MODE_MIN: {
+        this->filterModeMin = (enum TextureFilterMode)atoi(integer);
+        j = 0;
+        parseState = TEXTURE_ASSET_HEADER_PARSE_STATE_FILTER_MODE_MAG;
+        break;
+      }
+
+      case TEXTURE_ASSET_HEADER_PARSE_STATE_FILTER_MODE_MAG: {
+        this->filterModeMag = (enum TextureFilterMode)atoi(integer);
+        j = 0;
+        parseState = TEXTURE_ASSET_HEADER_PARSE_STATE_END;
+        break;
+      }
+
+      default:
+        assertUnreachable();
     }
-    integer[j++] = c;
   }
 
   this->colors = (struct Color *)((void *)(this->buffer + i));

src/dawn/asset/assets/TextureAsset.hpp

@@ -9,12 +9,29 @@
 #include "display/Texture.hpp"
 
 namespace Dawn {
+  enum TextureAssetHeaderParseState {
+    TEXTURE_ASSET_HEADER_PARSE_STATE_VERSION,
+    TEXTURE_ASSET_HEADER_PARSE_STATE_WIDTH,
+    TEXTURE_ASSET_HEADER_PARSE_STATE_HEIGHT,
+    TEXTURE_ASSET_HEADER_PARSE_STATE_FORMAT,
+    TEXTURE_ASSET_HEADER_PARSE_STATE_WRAP_MODE_X,
+    TEXTURE_ASSET_HEADER_PARSE_STATE_WRAP_MODE_Y,
+    TEXTURE_ASSET_HEADER_PARSE_STATE_FILTER_MODE_MIN,
+    TEXTURE_ASSET_HEADER_PARSE_STATE_FILTER_MODE_MAG,
+    TEXTURE_ASSET_HEADER_PARSE_STATE_END
+  };
+
   class TextureAsset : public Asset {
     protected:
       AssetLoader loader;
       uint8_t *buffer = nullptr;
       int32_t width = -1, height = -1;
       struct Color *colors;
+      enum TextureFormat format;
+      enum TextureWrapMode wrapModeX;
+      enum TextureWrapMode wrapModeY;
+      enum TextureFilterMode filterModeMin;
+      enum TextureFilterMode filterModeMag;
 
     public:
       Texture texture;

src/dawn/asset/assets/TrueTypeAsset.cpp

@@ -15,7 +15,7 @@ TrueTypeAsset::TrueTypeAsset(AssetManager *assMan, std::string name) :
 
 void TrueTypeAsset::updateSync() {
   if(this->state != 0x04) return;
-  this->font.texture.setSize(this->width, this->height);
+  this->font.texture.setSize(this->width, this->height, TEXTURE_FORMAT_RGBA);
   this->font.texture.buffer(this->pixels);
   auto i = this->pixels;
   memoryCopy(

src/dawn/display/_Texture.hpp

@@ -5,10 +5,46 @@
 
 #pragma once
 #include "display/Color.hpp"
+#include "state/StateOwner.hpp"
 
 namespace Dawn {
-  class ITexture {
+  enum TextureFormat {
+    TEXTURE_FORMAT_R = 1,
+    TEXTURE_FORMAT_RG = 2,
+    TEXTURE_FORMAT_RGB = 3,
+    TEXTURE_FORMAT_RGBA = 4
+  };
+
+  enum TextureWrapMode {
+    TEXTURE_WRAP_MODE_REPEAT = 0,
+    TEXTURE_WRAP_MODE_MIRRORED_REPEAT = 1,
+    TEXTURE_WRAP_MODE_CLAMP_TO_EDGE = 2,
+    TEXTURE_WRAP_MODE_CLAMP_TO_BORDER = 3
+  };
+
+  enum TextureFilterMode {
+    TEXTURE_FILTER_MODE_NEAREST = 0,
+    TEXTURE_FILTER_MODE_LINEAR = 1
+  };
+
+  class ITexture : public StateOwner {
+    protected:
+      bool_t texturePropertiesNeedUpdating = true;
+
     public:
+      StateProperty<enum TextureWrapMode> wrapModeX;
+      StateProperty<enum TextureWrapMode> wrapModeY;
+      StateProperty<enum TextureFilterMode> filterModeMin;
+      StateProperty<enum TextureFilterMode> filterModeMag;
+
+      ITexture() :
+        wrapModeX(TEXTURE_WRAP_MODE_CLAMP_TO_EDGE),
+        wrapModeY(TEXTURE_WRAP_MODE_CLAMP_TO_EDGE),
+        filterModeMin(TEXTURE_FILTER_MODE_LINEAR),
+        filterModeMag(TEXTURE_FILTER_MODE_LINEAR)
+      {
+      }
+
       /**
        * Returns the width of the texture.
        * 
@@ -28,8 +64,13 @@ namespace Dawn {
        * 
        * @param width Width of the texture (in pixels).
        * @param height Height of the texture (in pixels).
+       * @param format Data format of the texture to use.
        */
-      virtual void setSize(int32_t width, int32_t height) = 0;
+      virtual void setSize(
+        int32_t width,
+        int32_t height,
+        enum TextureFormat format
+      ) = 0;
 
       /**
        * Fill a texture with a single color. This is stupidly costly.

src/dawn/display/font/ExampleFont.cpp

@@ -99,6 +99,6 @@ void ExampleFont::init() {
     pixels[j++] = this->getColor(n & 0x01);
   }
 
-  this->realTexture.setSize(128, 64);
+  this->realTexture.setSize(128, 64, TEXTURE_FORMAT_RGBA);
   this->realTexture.buffer(pixels);
 }