TTF Prog

src/dawn/display/font/FontManager.cpp

@@ -7,9 +7,18 @@
 
 using namespace Dawn;
 
+FontManager::FontManager() {
+
+}
+
 void FontManager::init() {
+  // Init FreeType
   if(FT_Init_FreeType(&fontLibrary)) {
     std::cout << "ERROR::FREETYPE: Could not init FreeType Library" << std::endl;
     assertUnreachable();
   }
+}
+
+FontManager::~FontManager() {
+
 }

src/dawn/display/font/FontManager.hpp

@@ -14,6 +14,10 @@ namespace Dawn {
     public:
       FT_Library fontLibrary;
 
+      FontManager();
+
       void init();
+
+      ~FontManager();
   };
 }

src/dawn/display/font/NewTrueType.cpp

@@ -7,17 +7,30 @@
 
 using namespace Dawn;
 
-void Dawn::_newTrueTypePlaceholder(
-  FT_Face face,
-  Texture &texture,
-  std::map<FT_ULong, struct TrueTypeCharacterInfo> &charStore
+NewTrueTypeFaceTexture::NewTrueTypeFaceTexture(
+  NewTrueTypeFace *trueTypeFace,
+  FT_Face &face,
+  struct NewTrueTypeFaceTextureStyle style
 ) {
+  assertNotNull(trueTypeFace);
+  assertTrue(this->style.fontSize < 256);
+
+  this->trueTypeFace = trueTypeFace;
+  this->face = &face;
+  this->style = style;
+
+  // Set freetype font size prior to baking.
+  if(FT_Set_Pixel_Sizes(face, 0, this->style.fontSize)) {
+    assertUnreachable();
+  }
+
   size_t w = 0, h = 0;
   FT_ULong c;
 
+  // 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)) {
+    if(FT_Load_Char(face, c, FT_LOAD_RENDER | FT_LOAD_MONOCHROME)) {
       assertUnreachable();
     }
 
@@ -26,16 +39,18 @@ void Dawn::_newTrueTypePlaceholder(
     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 *)memoryAllocate(w * h * sizeof(uint8_t));
-  memorySet(buffer, 0x00, sizeof(uint8_t) * w * h);
+  uint8_t *buffer = (uint8_t *)memoryFillWithZero(w * h * sizeof(uint8_t));
 
   size_t offset = 0;
+  struct NewTrueTypeCharacter info;
   for(c = NEW_TRUETYPE_CHAR_BEGIN; c < NEW_TRUETYPE_CHAR_END; c++) {
     // Load the character
     if(FT_Load_Char(face, c, FT_LOAD_RENDER)) {
@@ -43,26 +58,51 @@ void Dawn::_newTrueTypePlaceholder(
     }
 
     // Store the character information
-    struct TrueTypeCharacterInfo info;
-    info.advance = glm::vec2(face->glyph->advance.x, face->glyph->advance.y);
+    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.bitmapPosition = glm::vec2(face->glyph->bitmap_left, -face->glyph->bitmap_top);
     info.textureY = y;
-    charStore[c] = info;
+    this->characterData[c] = info;
 
     // Buffer the pixels, oh dear GOD there has to be a more efficient way.
-    for(uint32_t i = 0; i < face->glyph->bitmap.rows; i++) {
+    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;
   }
 
-  texture.setSize(w, h, TEXTURE_FORMAT_R);
-  texture.buffer(buffer);
+  this->texture.setSize(w, h, TEXTURE_FORMAT_R);
+  this->texture.buffer(buffer);
   memoryFree(buffer);
+}
+
+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/NewTrueType.hpp

@@ -6,22 +6,90 @@
 #pragma once
 #include "dawnlibs.hpp"
 #include "util/mathutils.hpp"
+#include "util/flag.hpp"
 #include "display/Texture.hpp"
+#include "util/UsageLock.hpp"
 
-#define NEW_TRUETYPE_CHAR_BEGIN 0x00
-#define NEW_TRUETYPE_CHAR_END 0xFF
+#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 {
-  struct TrueTypeCharacterInfo {
-    glm::vec2 advance;
+  class NewTrueTypeFace;
+
+  typedef uint32_t newtruetypelock_t;
+
+  struct NewTrueTypeCharacter {
+    int32_t advanceX;
+    int32_t advanceY;
     glm::vec2 bitmapSize;
     glm::vec2 bitmapPosition;
     float_t textureY;
   };
 
-  void _newTrueTypePlaceholder(
-    FT_Face face,
-    Texture &texture,
-    std::map<FT_ULong, struct TrueTypeCharacterInfo> &charStore
-  );
+
+  struct NewTrueTypeFaceTextureStyle {
+    uint32_t fontSize;
+    flag_t style;
+  };
+
+  class NewTrueTypeFaceTexture {
+    protected:
+      FT_Face *face;
+      NewTrueTypeFace *trueTypeFace;
+      std::map<FT_ULong, struct NewTrueTypeCharacter> characterData;
+      struct NewTrueTypeFaceTextureStyle style;
+      UsageLock locks;
+
+    public:
+      Texture texture;
+
+      /**
+       * 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,
+        struct NewTrueTypeFaceTextureStyle style
+      );
+
+      /**
+       * Returns the character data for the given character.
+       * 
+       * @param c Character to get data for.
+       * @return The Character data for the given character.
+       */
+      struct NewTrueTypeCharacter getCharacterData(FT_ULong c);
+
+      /**
+       * Destroys this true type face texture.
+       */
+      ~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();
+  };
 }