Loading fonts is done

src/dawn/asset/assets/NewTrueTypeAsset.cpp

@@ -115,29 +115,6 @@ void NewTrueTypeAsset::updateAsync() {
   this->state = NEW_TRUE_TYPE_ASSET_STATE_INIT_FREETYPE;
   int32_t ret = FT_Init_FreeType(&fontLibrary);
   assertTrue(ret == 0);
-  
-  // Convert to truetype faces
-  this->state = NEW_TRUE_TYPE_ASSET_STATE_CONVERTING_TO_FACES;
-  itStyle = assetStyles.begin();
-  while(itStyle != assetStyles.end()) {
-    struct NewTrueTypeAssetStyle &style = (*itStyle);
-
-    uint8_t *dataBuffer = (uint8_t*)memoryAllocate(sizeof(uint8_t) * style.dataSize);
-    this->loader.rewind();
-    this->loader.setPosition(style.dataOffset);
-    read = this->loader.read(dataBuffer, style.dataSize);
-    assertTrue(read == style.dataSize);
-
-    // Create the face
-    NewTrueTypeFace *face = new NewTrueTypeFace();
-    ret = FT_New_Memory_Face(this->fontLibrary, (FT_Byte*)dataBuffer, style.dataSize, 0, &face->face);
-    memoryFree(dataBuffer);
-    assertTrue(ret == 0);
-
-    // Push
-    this->faces[style.style] = face;
-    ++itStyle;
-  }
 
   // Done parsing!
   this->state = NEW_TRUE_TYPE_ASSET_STATE_READY;
@@ -145,33 +122,67 @@ void NewTrueTypeAsset::updateAsync() {
 }
 
 usagelockid_t NewTrueTypeAsset::lock(struct NewTrueTypeFaceTextureStyle style) {
-  // Try find style
+  assertTrue(this->state == NEW_TRUE_TYPE_ASSET_STATE_READY);
-  auto it = this->faces.find(style.style);
-  assertTrue(it != this->faces.end());
 
-  auto lock = it->second->lock(style);
+  // Try and find an existing texture that matches this style
-  this->locks[lock] = style;
+  auto it = this->textureByStyle.find(style);
+  NewTrueTypeFaceTexture *texture = nullptr;
+
+  if(it == this->textureByStyle.end()) {
+    // Does not exist, Find asset style
+    auto itAssetStyle = this->assetStyles.begin();
+    while(itAssetStyle != this->assetStyles.end()) {
+      if((*itAssetStyle).style == style.style) {
+        // Found
+        break;
+      }
+      ++itAssetStyle;
+    }
+    assertTrue(itAssetStyle != this->assetStyles.end());
+
+    // Create and read buffer.
+    uint8_t *dataBuffer = (uint8_t*)memoryAllocate(sizeof(uint8_t) * itAssetStyle->dataSize);
+    this->loader.rewind();
+    this->loader.setPosition(itAssetStyle->dataOffset);
+    auto read = this->loader.read(dataBuffer, itAssetStyle->dataSize);
+    assertTrue(read == itAssetStyle->dataSize);
+
+    // Create the face
+    FT_Face face;
+    auto ret = FT_New_Memory_Face(this->fontLibrary, (FT_Byte*)dataBuffer, itAssetStyle->dataSize, 0, &face);
+    assertTrue(ret == 0);
+    texture = new NewTrueTypeFaceTexture(face, style);
+    memoryFree(dataBuffer);
+
+    this->textures.push_back(texture);
+    this->textureByStyle[style] = texture;
+  } else {
+    // Exists
+    texture = it->second;
+  }
+
+  auto lock = texture->locks.createLock();
+  this->textureByLock[lock] = texture;
   return lock;
 }
 
 NewTrueTypeFaceTexture * NewTrueTypeAsset::getTexture(usagelockid_t id) {
-  auto existing = this->locks.find(id);
+  auto it = this->textureByLock.find(id);
-  assertTrue(existing != this->locks.end());
+  assertTrue(it != this->textureByLock.end());
-  return this->faces[existing->second.style]->getTexture(id);
+  return it->second;
 }
 
 void NewTrueTypeAsset::unlock(usagelockid_t id) {
-  auto existing = this->locks.find(id);
+  auto it = this->textureByLock.find(id);
-  assertTrue(existing != this->locks.end());
+  assertTrue(it != this->textureByLock.end());
-  this->faces[existing->second.style]->unlock(id);
+  it->second->locks.removeLock(id);
-  this->locks.erase(existing);
+  this->textureByLock.erase(it);
 }
 
 NewTrueTypeAsset::~NewTrueTypeAsset() {
-  auto it = this->faces.begin();
+  auto it = this->textures.begin();
-  while(it != this->faces.end()) {
+  while(it != this->textures.end()) {
-    FT_Done_Face(it->second->face);
+    delete (*it);
-    delete it->second;
     it++;
   }
 

src/dawn/asset/assets/NewTrueTypeAsset.hpp

@@ -7,7 +7,7 @@
 #include "../Asset.hpp"
 #include "../AssetLoader.hpp"
 #include "util/flag.hpp"
-#include "display/font/truetype/NewTrueTypeFace.hpp"
+#include "display/font/truetype/NewTrueTypeFaceTexture.hpp"
 
 namespace Dawn {
   enum NewTrueTypeAssetState {
@@ -19,7 +19,6 @@ namespace Dawn {
     NEW_TRUE_TYPE_ASSET_STATE_READ_VARIANT,
     NEW_TRUE_TYPE_ASSET_STATE_ADJUSTING_OFFSETS,
     NEW_TRUE_TYPE_ASSET_STATE_INIT_FREETYPE,
-    NEW_TRUE_TYPE_ASSET_STATE_CONVERTING_TO_FACES,
     NEW_TRUE_TYPE_ASSET_STATE_READY
   };
 
@@ -35,24 +34,18 @@ namespace Dawn {
       FT_Library fontLibrary;
       enum NewTrueTypeAssetState state = NEW_TRUE_TYPE_ASSET_STATE_INITIAL;
       std::vector<struct NewTrueTypeAssetStyle> assetStyles;
-      std::map<flag_t, NewTrueTypeFace*> faces;
+
-      std::map<usagelockid_t, struct NewTrueTypeFaceTextureStyle> locks;
+      std::vector<NewTrueTypeFaceTexture*> textures;
+      std::map<usagelockid_t, NewTrueTypeFaceTexture*> textureByLock;
+      std::map<struct NewTrueTypeFaceTextureStyle, NewTrueTypeFaceTexture*> textureByStyle;
 
     public:
       NewTrueTypeAsset(AssetManager *assMan, std::string name);
       void updateSync() override;
       void updateAsync() override;
 
-      /**
-       * Locks a specific style for use later.
-       * 
-       * @param style Style you want to lock.
-       * @return A unique lock ID for this style.
-       */
       usagelockid_t lock(struct NewTrueTypeFaceTextureStyle style);
-
       NewTrueTypeFaceTexture * getTexture(usagelockid_t lock);
-
       void unlock(usagelockid_t lock);
 
       ~NewTrueTypeAsset();

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

@@ -6,6 +6,5 @@
 # Sources
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
-    NewTrueTypeFace.cpp
     NewTrueTypeFaceTexture.cpp
 )

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

@@ -1,57 +0,0 @@
-// Copyright (c) 2023 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#include "asset/assets/NewTrueTypeAsset.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()) {
-    // Does not exist, create it.
-    texture = new NewTrueTypeFaceTexture(this, face, style);
-    this->textures.push_back(texture);
-    this->texturesByStyle[style] = texture;
-  } 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);
-  assertNotNull(texture);
-  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;
-  }
-}

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

@@ -1,55 +0,0 @@
-// 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 {
-    public:
-      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;
-      FT_Face face;
-
-      /**
-       * 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();
-  };
-}

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

@@ -3,28 +3,25 @@
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
-#include "NewTrueTypeFace.hpp"
+#include "NewTrueTypeFaceTexture.hpp"
 
 using namespace Dawn;
 
 NewTrueTypeFaceTexture::NewTrueTypeFaceTexture(
-  NewTrueTypeFace *trueTypeFace,
+  FT_Face face,
-  FT_Face &face,
   struct NewTrueTypeFaceTextureStyle style
 ) {
-  assertNotNull(trueTypeFace);
   assertTrue(style.fontSize < 256);
 
-  this->trueTypeFace = trueTypeFace;
+  this->face = face;
-  this->face = &face;
   this->style = style;
   
   this->locks.onEmpty = [&]() {
-    delete this;
+    assertUnreachable();
   };
 
   // Set freetype font size prior to baking.
-  if(FT_Set_Pixel_Sizes(face, 0, this->style.fontSize)) {
+  if(FT_Set_Pixel_Sizes(face, 0, style.fontSize)) {
     assertUnreachable();
   }
 
@@ -34,7 +31,8 @@ NewTrueTypeFaceTexture::NewTrueTypeFaceTexture(
   // First pass, determine the textures' dimensions.
   for(c = NEW_TRUETYPE_CHAR_BEGIN; c < NEW_TRUETYPE_CHAR_END; c++) {
     // Load the character
-    if(FT_Load_Char(face, c, FT_LOAD_RENDER | FT_LOAD_MONOCHROME)) {
+    auto ret = FT_Load_Char(face, c, FT_LOAD_BITMAP_METRICS_ONLY);
+    if(ret) {
       assertUnreachable();
     }
 
@@ -62,11 +60,15 @@ NewTrueTypeFaceTexture::NewTrueTypeFaceTexture(
     }
 
     // Store the character information
-    info.advanceX = face->glyph->advance.x;
+    info.advanceX = (float_t)(face->glyph->advance.x >> 6);
-    info.advanceY = face->glyph->advance.y;
+    info.advanceY = (float_t)(face->glyph->advance.y >> 6);
     info.bitmapSize = glm::vec2(face->glyph->bitmap.width, face->glyph->bitmap.rows);
     info.bitmapPosition = glm::vec2(face->glyph->bitmap_left, -face->glyph->bitmap_top);
     info.textureY = y;
+    char c2 = (char)c;
+    if(c2 == 'H') {
+      std::cout << "H" << std::endl;
+    }
     this->characterData[c] = info;
 
     // Buffer the pixels, oh dear GOD there has to be a more efficient way.
@@ -92,11 +94,5 @@ struct NewTrueTypeCharacter NewTrueTypeFaceTexture::getCharacterData(FT_ULong c)
 }
 
 NewTrueTypeFaceTexture::~NewTrueTypeFaceTexture() {
-  auto it = std::find(
+  FT_Done_Face(this->face);
-    this->trueTypeFace->textures.begin(),
-    this->trueTypeFace->textures.end(),
-    this
-  );
-  assertTrue(it != this->trueTypeFace->textures.end());
-  this->trueTypeFace->textures.erase(it);
 }

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

@@ -10,13 +10,11 @@
 #include "util/UsageLock.hpp"
 
 namespace Dawn {
-  class NewTrueTypeFace;
+  class NewTrueTypeAsset;
-
-  typedef uint32_t newtruetypelock_t;
 
   struct NewTrueTypeCharacter {
-    int32_t advanceX;
+    float_t advanceX;
-    int32_t advanceY;
+    float_t advanceY;
     glm::vec2 bitmapSize;
     glm::vec2 bitmapPosition;
     float_t textureY;
@@ -33,8 +31,7 @@ namespace Dawn {
 
   class NewTrueTypeFaceTexture {
     public:
-      FT_Face *face;
+      FT_Face face;
-      NewTrueTypeFace *trueTypeFace;
       std::map<FT_ULong, struct NewTrueTypeCharacter> characterData;
       struct NewTrueTypeFaceTextureStyle style;
       UsageLock locks;
@@ -43,13 +40,11 @@ namespace Dawn {
       /**
        * Construct a new New True Type Face Texture object
        * 
-       * @param trueTypeFace Face that this texture belongs to.
        * @param face The freetype face object.
        * @param style Style that this font has, used for locking.
        */
       NewTrueTypeFaceTexture(
-        NewTrueTypeFace *trueTypeFace,
+        FT_Face face,
-        FT_Face &face,
         struct NewTrueTypeFaceTextureStyle style
       );
 
@@ -66,6 +61,6 @@ namespace Dawn {
        */
       ~NewTrueTypeFaceTexture();
 
-      friend class NewTrueTypeFace;
+      friend class NewTrueTypeAsset;
   };
 }

src/dawn/scene/components/ui/UILabelNew.cpp

@@ -18,16 +18,43 @@ UILabelNew::UILabelNew(SceneItem *item) :
 }
 
 void UILabelNew::rebufferQuads() {
+  std::cout << "Rebuffering" << std::endl;
   this->mesh.createBuffers(QUAD_VERTICE_COUNT * 128, QUAD_INDICE_COUNT * 128);
 
-  auto texture = this->font->getTexture(this->fontLock);
+  glm::vec2 position(32, 32);
-  texture.
+
+  struct FontShaderBufferData fontData;
+  auto x = this->bufferQuads(
+    "Hello World",
+    fontData,
+    this->font->getTexture(this->fontLock),
+    position,
+    0,
+    0
+  );
+
+  fontData.colors[0] = COLOR_MAGENTA;
+  fontData.textures[0] = 0;
+  // fontData.colors[1] = COLOR_RED;
+  // fontData.textures[1] = 1;
+  // fontData.colors[2] = COLOR_GREEN;
+  // fontData.textures[2] = 2;
+  shaderBuffer.buffer(&fontData);
 }
 
 void UILabelNew::onStart() {
   this->shaderBuffer.init();
 
   useEffect([&]{
+    usagelockid_t newLock = -1;
+
+    if(font != nullptr) {
+      newLock = font->lock(NewTrueTypeFaceTextureStyle{
+        fontSize,
+        style
+      });
+    }
+
     if(fontLock != -1) {
       font.previous->unlock(fontLock);
       fontLock = -1;
@@ -35,62 +62,25 @@ void UILabelNew::onStart() {
 
     if(font == nullptr) return;
 
-    fontLock = font->lock(NewTrueTypeFaceTextureStyle{
+    fontLock = newLock;
-      fontSize,
+    this->rebufferQuads();
-      style
+  }, font)();
-    });
-  }, font);
 
   useEffect([&]{
     if(font == nullptr) return;
+    auto newLock = font->lock(NewTrueTypeFaceTextureStyle{
+      fontSize,
+      style
+    });
 
     if(fontLock != -1) {
       font->unlock(fontLock);
       fontLock = -1;
     }
 
-    fontLock = font->lock(NewTrueTypeFaceTextureStyle{
+    fontLock = newLock;
-      fontSize,
+    this->rebufferQuads();
-      style
+  }, { &fontSize, &style })();
-    });
-  }, { &fontSize, &style });
-
-  // struct FontShaderBufferData fontData;
-  // glm::vec2 position = glm::vec2(32, 32);
-
-  // mesh.createBuffers(QUAD_VERTICE_COUNT * 128, QUAD_INDICE_COUNT * 128);
-  // auto x = UILabelNew::bufferQuads(
-  //   "Hello ",
-  //   fontData,
-  //   defFace,
-  //   position,
-  //   0,
-  //   0
-  // );
-  // x += UILabelNew::bufferQuads(
-  //   " World",
-  //   fontData,
-  //   defFaceItalics,
-  //   position,
-  //   x,
-  //   1
-  // );
-  // x += UILabelNew::bufferQuads(
-  //   " How are you?",
-  //   fontData,
-  //   defFaceBold,
-  //   position,
-  //   x,
-  //   2
-  // );
-
-  // fontData.colors[0] = COLOR_MAGENTA;
-  // fontData.textures[0] = 0;
-  // fontData.colors[1] = COLOR_RED;
-  // fontData.textures[1] = 1;
-  // fontData.colors[2] = COLOR_GREEN;
-  // fontData.textures[2] = 2;
-  // shaderBuffer.buffer(&fontData);
 }
 
 std::vector<struct ShaderPassItem> UILabelNew::getUIRenderPasses() {
@@ -106,10 +96,11 @@ std::vector<struct ShaderPassItem> UILabelNew::getUIRenderPasses() {
   item.parameterBuffers[shader->bufferUiCanvas] = &canvas->shaderBuffer;
   item.parameterBuffers[shader->bufferFont] = &this->shaderBuffer;
   item.renderFlags = RENDER_MANAGER_RENDER_FLAG_BLEND;
-  // item.textureSlots[0] = &defFace.texture;
+
+  item.textureSlots[0] = &this->font->getTexture(this->fontLock)->texture;
+  item.textureValues[shader->paramTexture0] = 0;
   // item.textureSlots[1] = &defFaceItalics.texture;
   // item.textureSlots[2] = &defFaceBold.texture;
-  // item.textureValues[shader->paramTexture0] = 0;
   // item.textureValues[shader->paramTexture1] = 1;
   // item.textureValues[shader->paramTexture2] = 2;
 
@@ -133,115 +124,45 @@ float_t UILabelNew::getContentHeight() {
   return 0;
 }
 
-// void UILabelNew::bakeTexture(
+int32_t UILabelNew::bufferQuads(
-//   struct UILabelFontDef &fontDef,
+  std::string text,
-//   FT_Face &face,
+  struct FontShaderBufferData &bufferData,
-//   uint32_t fontSize
+  struct NewTrueTypeFaceTexture *texture,
-// ) {
+  glm::vec2 &position,
-//   fontDef.face = &face;
+  int32_t quadStart,
-//   fontDef.fontSize = fontSize;
+  int32_t partIndex
-
+) {
-//   if(FT_Set_Pixel_Sizes(face, 0, fontSize)) {
+  // Get string length
-//     assertUnreachable();
+  int32_t len = text.length();
-//   }
-
-//   size_t w = 0, h = 0;
-//   FT_ULong c;
-
-//   for(c = NEW_LABEL_CHAR_BEGIN; c < NEW_LABEL_CHAR_END; c++) {
-//     // Load the character
-//     if(FT_Load_Char(face, c, FT_LOAD_RENDER | FT_LOAD_MONOCHROME)) {
-//       assertUnreachable();
-//     }
-
-//     // Update the width and height
-//     w = mathMax<size_t>(w, face->glyph->bitmap.width);
-//     h += face->glyph->bitmap.rows;
-//   }
-
-//   assertTrue(w > 0);
-//   assertTrue(h > 0);
-
-//   // Now buffer pixels to the texture
-//   float_t y = 0;
-
-//   // I'd love to just buffer straight to the GPU, but it seems that is a bit 
-//   // unstable right now.
-//   uint8_t *buffer = (uint8_t *)memoryFillWithZero(w * h * sizeof(uint8_t));
-
-//   size_t offset = 0;
-//   for(c = NEW_LABEL_CHAR_BEGIN; c < NEW_LABEL_CHAR_END; c++) {
-//     // Load the character
-//     if(FT_Load_Char(face, c, FT_LOAD_RENDER)) {
-//       assertUnreachable();
-//     }
-
-//     // Store the character information
-//     struct UILabelChar info;
-//     info.advanceX = face->glyph->advance.x;
-//     info.advanceY = face->glyph->advance.y;
-//     info.bitmapSize = glm::vec2(face->glyph->bitmap.width, face->glyph->bitmap.rows);
-//     info.bitmapPosition = glm::vec2(face->glyph->bitmap_left, -face->glyph->bitmap_top);
-//     info.textureY = y;
-//     fontDef.charStore[c] = info;
-
-//     // Buffer the pixels, oh dear GOD there has to be a more efficient way.
-//     for(int32_t i = 0; i < face->glyph->bitmap.rows; i++) {
-//       memoryCopy(
-//         (void *)(face->glyph->bitmap.buffer + (i * face->glyph->bitmap.width)),
-//         (void *)(buffer + offset),
-//         face->glyph->bitmap.width * sizeof(uint8_t)
-//       );
-//       offset += w * sizeof(uint8_t);
-//       assertTrue(offset <= (w * h * sizeof(uint8_t)));
-//     }
-//     y += face->glyph->bitmap.rows;
-//   }
-
-//   fontDef.texture.setSize(w, h, TEXTURE_FORMAT_R);
-//   fontDef.texture.buffer(buffer);
-//   memoryFree(buffer);
-// }
-
-// int32_t UILabelNew::bufferQuads(
-//   std::string text,
-//   struct FontShaderBufferData &bufferData,
-//   struct UILabelFontDef &fontDef,
-//   glm::vec2 &position,
-//   int32_t quadStart,
-//   int32_t partIndex
-// ) {
-//   // Get string length
-//   int32_t len = text.length();
   
-//   glm::vec2 wh = glm::vec2(fontDef.texture.getWidth(), fontDef.texture.getHeight());
+  glm::vec2 wh = glm::vec2(texture->texture.getWidth(), texture->texture.getHeight());
 
-//   // For each char
+  // For each char
-//   for(int32_t i = 0; i < len; i++) {
+  for(int32_t i = 0; i < len; i++) {
-//     char ch = text[i];
+    char ch = text[i];
-//     int32_t j = quadStart + i;
+    int32_t j = quadStart + i;
-//     FT_ULong c = ch;
+    FT_ULong c = ch;
-//     auto &charInfo = fontDef.charStore[c];
+    auto charInfo = texture->getCharacterData(c);
 
-//     // Determine texture coordinates.
+    // Determine texture coordinates.
-//     glm::vec2 uv0 = glm::vec2(0.0f, charInfo.textureY) / wh;
+    glm::vec2 uv0 = glm::vec2(0.0f, charInfo.textureY) / wh;
-//     glm::vec2 uv1 = uv0 + (charInfo.bitmapSize / wh);
+    glm::vec2 uv1 = uv0 + (charInfo.bitmapSize / wh);
 
-//     // Buffer the quad.
+    // Buffer the quad.
-//     QuadMesh::bufferQuadMeshWithZ(&this->mesh,
+    QuadMesh::bufferQuadMeshWithZ(&this->mesh,
-//       position + charInfo.bitmapPosition, uv0,
+      position + charInfo.bitmapPosition, uv0,
-//       position + charInfo.bitmapPosition + charInfo.bitmapSize, uv1,
+      position + charInfo.bitmapPosition + charInfo.bitmapSize, uv1,
-//       0.0f,
+      0.0f,
-//       j * QUAD_VERTICE_COUNT, j * QUAD_INDICE_COUNT
+      j * QUAD_VERTICE_COUNT, j * QUAD_INDICE_COUNT
-//     );
+    );
 
-//     // Move the current position along.
+    // Move the current position along.
-//     position.x += (float_t)(charInfo.advanceX >> 6);
+    position.x += charInfo.advanceX;
-//     position.y += (float_t)(charInfo.advanceY >> 6);
+    position.y += charInfo.advanceY;
 
-//     // Set the part index to the quad mappings
+    // Set the part index to the quad mappings
-//     bufferData.fontQuadMappings[j] = partIndex;
+    bufferData.fontQuadMappings[j] = partIndex;
-//   }
+  }
 
-//   return len;
+  return len;
-// }
+}

src/dawn/scene/components/ui/UILabelNew.hpp

@@ -35,20 +35,20 @@ namespace Dawn {
        * 
        * @param text Text to buffer.
        * @param bufferData The output quad mappings for the text.
-       * @param fontDef The font definition to use.
+       * @param texture The font texture definition to use.
        * @param position The 2D position to buffer the quads at.
        * @param quadStart The starting quad index.
        * @param partIndex The part index to store for each quad buffered.
        * @return The number of quads buffered, not the string length.
        */
-      // int32_t bufferQuads(
+      int32_t bufferQuads(
-      //   std::string text,
+        std::string text,
-      //   struct FontShaderBufferData &bufferData,
+        struct FontShaderBufferData &bufferData,
-      //   struct UILabelFontDef &fontDef,
+        struct NewTrueTypeFaceTexture *texture,
-      //   glm::vec2 &position,
+        glm::vec2 &position,
-      //   int32_t quadStart,
+        int32_t quadStart,
-      //   int32_t partIndex
+        int32_t partIndex
-      // );
+      );
 
       void rebufferQuads();
 

src/dawnliminal/scenes/HelloWorldScene.hpp

@@ -29,36 +29,8 @@ namespace Dawn {
         auto newLabel = newLabelItem->addComponent<UILabelNew>();
 
         auto font = this->game->assetManager.get<NewTrueTypeAsset>("font_arial");
-        
+        newLabel->font = font;
-        struct NewTrueTypeFaceTextureStyle style;
+        newLabel->fontSize = 32;
-        style.fontSize = 16;
-        style.style = 0;
-
-        // item = this->createSceneItem();
-        // auto meshRenderer = item->addComponent<MeshRenderer>();
-        // auto quadMeshHost = item->addComponent<QuadMeshHost>();
-        // auto material = item->addComponent<SimpleTexturedMaterial>();
-
-        // if(FT_New_Face(
-        //   this->game->renderManager.getFontManager()->fontLibrary,
-        //   "C:\\Windows\\Fonts\\Arial.ttf",
-        //   0,
-        //   &face
-        // )) {
-        //   assertUnreachable();
-        // }
-        // if(FT_Set_Pixel_Sizes(face, 0, 16)) {
-        //   assertUnreachable();
-        // }
-
-        // _newTrueTypePlaceholder(face, texture, charStore);
-        // FT_ULong c = 'B';
-        // auto x = charStore[c];
-        // glm::vec2 wh = glm::vec2(texture.getWidth(), texture.getHeight());
-        // quadMeshHost->uv0 = glm::vec2(0.0f, x.textureY) / wh;
-        // quadMeshHost->uv1 = (glm::vec2)quadMeshHost->uv0 + (x.bitmapSize / wh);
-        // std::cout << "Done" << std::endl;
-        // material->texture = &texture;
       }
       
       std::vector<Asset*> getRequiredAssets() override {

src/dawntools/newtruetypetool/NewTrueTypeTool.cpp

@@ -9,12 +9,17 @@ using namespace Dawn;
 
 NewTrueTypeFile::NewTrueTypeFile(std::string path) : file(path) {
   this->path = path;
+  
+  // Remove extension
+  size_t pos = path.find_last_of(".");
+  std::string filename = path.substr(0, pos);
+
 
   style = 0;
-  if(path.find("bold") != std::string::npos) {
+  if(path.find("bold") != std::string::npos || filename.ends_with("bd") || filename.ends_with("bi")) {
     style |= NEW_TRUETYPE_VARIANT_BOLD;
   }
-  if(path.find("italics") != std::string::npos) {
+  if(path.find("italics") != std::string::npos || filename.ends_with("i") || filename.ends_with("bi")) {
     style |= NEW_TRUETYPE_VARIANT_ITALICS;
   }