Font loading progress

src/dawn/asset/assets/NewTrueTypeAsset.hpp

@@ -0,0 +1,31 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "../Asset.hpp"
+#include "../AssetLoader.hpp"
+
+namespace Dawn {
+  enum NewTrueTypeAssetState {
+    NEW_TRUE_TYPE_ASSET_STATE_INITIAL,
+    NEW_TRUE_TYPE_ASSET_STATE_OPEN,
+    // NEW_TRUE_TYPE_ASSET_STATE_LOAD_RAW,
+    NEW_TRUE_TYPE_ASSET_STATE_VALIDATE_HEADER,
+    NEW_TRUE_TYPE_ASSET_STATE_VALIDATE_VERSION,
+    NEW_TRUE_TYPE_ASSET_STATE_READ_VARIANT_COUNT,
+  }
+
+  class NewTrueTypeAsset : public Asset {
+    protected:
+      AssetLoader loader;
+      enum NewTrueTypeAssetState state = NEW_TRUE_TYPE_ASSET_STATE_INITIAL;
+
+    public:
+      NewTrueTypeAsset(AssetManager *assMan, std::string name);
+      void updateSync() override;
+      void updateAsync() override;
+      ~NewTrueTypeAsset();
+  };
+}

src/dawn/display/font/CMakeLists.txt

@@ -11,5 +11,6 @@ target_sources(${DAWN_TARGET_NAME}
     ExampleFont.cpp
     TrueTypeFont.cpp
     FontMeasure.cpp
-    NewTrueType.cpp
-)
+)
+
+add_subdirectory(truetype)

src/dawn/display/font/truetype/CMakeLists.txt

@@ -0,0 +1,12 @@
+# Copyright (c) 2023 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    NewTrueType.cpp
+    NewTrueTypeFace.cpp
+    NewTrueTypeFaceTexture.hpp
+)

src/dawn/display/font/truetype/NewTrueType.cpp

@@ -0,0 +1,28 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "NewTrueType.hpp"
+
+using namespace Dawn;
+
+NewTrueType::NewTrueType(FontManager *fontMan) {
+  assertNotNull(fontMan);
+  this->fontManager = fontMan;
+}
+
+void NewTrueType::addStyle(flag_t style) {
+  assertTrue(this->faces.find(style) == this->faces.end());
+
+  //Create the face
+  this->faces[style] = new NewTrueTypeFace();
+}
+
+NewTrueType::~NewTrueType() {
+  auto it = this->faces.begin();
+  while(it != this->faces.end()) {
+    delete it->second;
+    it++;
+  }
+}

src/dawn/display/font/truetype/NewTrueType.hpp

@@ -0,0 +1,24 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "NewTrueTypeFace.hpp"
+#include "display/font/FontManager.hpp"
+
+namespace Dawn {
+  class NewTrueType {
+    protected:
+      std::map<flag_t, NewTrueTypeFace*> faces;
+      FontManager *fontManager;
+
+    public:
+      NewTrueType(FontManager *fontMan);
+      void addStyle(flag_t style);
+      NewTrueTypeFace * getFace(flag_t style);
+      ~NewTrueType();
+
+      friend class NewTrueTypeFace;
+  };
+}

src/dawn/display/font/truetype/NewTrueTypeFace.cpp

@@ -0,0 +1,64 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "NewTrueType.hpp"
+
+using namespace Dawn;
+
+NewTrueTypeFace::NewTrueTypeFace() {
+}
+
+usagelockid_t NewTrueTypeFace::lock(struct NewTrueTypeFaceTextureStyle style) {
+  // Find by style
+  NewTrueTypeFaceTexture *texture = nullptr;
+  auto existing = this->texturesByStyle.find(style);
+  if(existing == this->texturesByStyle.end()) {
+    // Load face
+    FT_Face face;
+    assertUnreachable();
+
+    // Does not exist, create it.
+    texture = new NewTrueTypeFaceTexture(this, face, style);
+    this->textures.push_back(texture);
+    this->texturesByStyle[style] = texture;
+    
+    // Cleanup face
+    FT_Done_Face(face);
+  } else {
+    texture = existing->second;
+  }
+
+  assertNotNull(texture);
+  auto lock = texture->locks.createLock();
+  this->locksByStyle[style].push_back(lock);
+  this->stylesByLock[lock] = style;
+
+  return lock;
+}
+
+NewTrueTypeFaceTexture * NewTrueTypeFace::getTexture(usagelockid_t lock) {
+  auto styleByLock = this->stylesByLock.find(lock);
+  assertTrue(styleByLock != this->stylesByLock.end());
+  auto texture = this->texturesByStyle.find(styleByLock->second);
+  assertTrue(texture != this->texturesByStyle.end());
+  return texture->second; 
+}
+
+void NewTrueTypeFace::unlock(usagelockid_t lock) {
+  auto texture = this->getTexture(lock);
+  texture->locks.removeLock(lock);
+  this->stylesByLock.erase(lock);
+  auto it = std::find(this->locksByStyle[texture->style].begin(), this->locksByStyle[texture->style].end(), lock);
+  assertTrue(it != this->locksByStyle[texture->style].end());
+  this->locksByStyle[texture->style].erase(it);
+}
+
+NewTrueTypeFace::~NewTrueTypeFace() {
+  auto it = this->textures.begin();
+  while(it != this->textures.end()) {
+    delete *it;
+    it = this->textures.erase(it);
+  }
+}

src/dawn/display/font/truetype/NewTrueTypeFace.hpp

@@ -0,0 +1,57 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "NewTrueTypeFaceTexture.hpp"
+
+namespace Dawn {
+  class NewTrueTypeFace {
+    protected:
+      std::vector<NewTrueTypeFaceTexture*> textures;
+      std::map<struct NewTrueTypeFaceTextureStyle, NewTrueTypeFaceTexture*> texturesByStyle;
+      std::map<struct NewTrueTypeFaceTextureStyle, std::vector<usagelockid_t>> locksByStyle;
+      std::map<usagelockid_t, struct NewTrueTypeFaceTextureStyle> stylesByLock;
+
+    public:
+      /**
+       * Create a new TrueTypeFace object. TrueType face holds multiple textures
+       * of various styles of this face. This face may be "Arial Bold" and have
+       * a texture for "Arial Bold 12", "Arial Bold 14", etc.
+       */
+      NewTrueTypeFace();
+
+      /**
+       * Locks a texture for use. This will create a new texture if one does not
+       * exist for the given style.
+       * 
+       * @param style Style to lock.
+       * @return A unique lock ID for this style.
+       */
+      usagelockid_t lock(struct NewTrueTypeFaceTextureStyle style);
+
+      /**
+       * Unlocks a previously created lock. If the texture becomes unused it 
+       * will be deleted.
+       * 
+       * @param lock Lock to remove.
+       */
+      void unlock(usagelockid_t lock);
+
+      /**
+       * Gets a texture from a lock.
+       * 
+       * @param lock Lock to get texture from.
+       * @return Texture from lock.
+       */
+      NewTrueTypeFaceTexture * getTexture(usagelockid_t lock);
+
+      /**
+       * Destroys this TrueTypeFace object, and all textures associated with it.
+       */
+      ~NewTrueTypeFace();
+
+      friend class NewTrueType;
+  };
+}

src/dawn/display/font/truetype/NewTrueTypeFaceTexture.cpp

@@ -3,7 +3,7 @@
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
-#include "NewTrueType.hpp"
+#include "NewTrueTypeFaceTexture.hpp"
 
 using namespace Dawn;
 
@@ -85,24 +85,4 @@ NewTrueTypeFaceTexture::NewTrueTypeFaceTexture(
 
 struct NewTrueTypeCharacter NewTrueTypeFaceTexture::getCharacterData(FT_ULong c) {
   return this->characterData[c];
-}
-
-
-
-
-NewTrueTypeFace::NewTrueTypeFace(FT_Face *face) {
-  assertNotNull(face);
-  this->face = face;
-}
-
-usagelockid_t NewTrueTypeFace::lock(struct NewTrueTypeFaceTextureStyle style) {
-  
-}
-
-NewTrueTypeFace::~NewTrueTypeFace() {
-  auto it = this->textures.begin();
-  while(it != this->textures.end()) {
-    delete *it;
-    it = this->textures.erase(it);
-  }
 }

src/dawn/display/font/truetype/NewTrueTypeFaceTexture.hpp

@@ -4,20 +4,14 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawnlibs.hpp"
+#include "display/font/truetype/NewTrueTypeShared.hpp"
 #include "util/mathutils.hpp"
-#include "util/flag.hpp"
 #include "display/Texture.hpp"
 #include "util/UsageLock.hpp"
 
-#define NEW_TRUETYPE_CHAR_BEGIN 32
-#define NEW_TRUETYPE_CHAR_END 192
-
-#define NEW_TRUETYPE_VARIANT_BOLD FLAG_DEFINE(0)
-#define NEW_TRUETYPE_VARIANT_ITALICS FLAG_DEFINE(1)
-
 namespace Dawn {
   class NewTrueTypeFace;
+  class NewTrueType;
 
   typedef uint32_t newtruetypelock_t;
 
@@ -29,7 +23,6 @@ namespace Dawn {
     float_t textureY;
   };
 
-
   struct NewTrueTypeFaceTextureStyle {
     uint32_t fontSize;
     flag_t style;
@@ -73,23 +66,6 @@ namespace Dawn {
       ~NewTrueTypeFaceTexture();
 
       friend class NewTrueTypeFace;
-  };
-
-
-
-
-  class NewTrueTypeFace {
-    protected:
-      std::vector<NewTrueTypeFaceTexture*> textures;
-      FT_Face *face;
-      std::map<struct NewTrueTypeFaceTextureStyle, NewTrueTypeFaceTexture*> texturesByStyle;
-      std::map<struct NewTrueTypeFaceTextureStyle, std::vector<usagelockid_t>> locksByStyle;
-
-    public:
-      NewTrueTypeFace(FT_Face *face);
-      usagelockid_t lock(struct NewTrueTypeFaceTextureStyle style);
-      void unlock(usagelockid_t lock);
-      NewTrueTypeFaceTexture * getTexture(usagelockid_t lock);
-      ~NewTrueTypeFace();
+      friend class NewTrueType;
   };
 }