Font loading progress

assets/test.txt

@@ -0,0 +1 @@
+9Test6

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;
   };
 }

src/dawnliminal/CMakeLists.txt

@@ -19,10 +19,17 @@ add_subdirectory(save)
 # Assets
 set(LIMINAL_ASSETS_DIR ${DAWN_ASSETS_DIR}/games/liminal)
 
-tool_truetype(font_main FILE=${LIMINAL_ASSETS_DIR}/fonts/Ysabeau-Medium.ttf)
+# tool_truetype(font_main FILE=${LIMINAL_ASSETS_DIR}/fonts/Ysabeau-Medium.ttf)
 tool_texture(texture_eth FILE=${LIMINAL_ASSETS_DIR}/textures/eth.png)
 tool_texture(texture_border FILE=${LIMINAL_ASSETS_DIR}/textures/texture_test.png)
 
+tool_newtruetype(font_arial
+  REGULAR="C:\\Windows\\Fonts\\arial.ttf"
+  BOLD="C:\\Windows\\Fonts\\arialbd.ttf"
+  ITALICS="C:\\Windows\\Fonts\\ariali.ttf"
+  BOLD_ITALICS="C:\\Windows\\Fonts\\arialbi.ttf"
+)
+
 tool_scene(${LIMINAL_ASSETS_DIR}/scenes/SceneBase.xml)
 tool_vnscene(${LIMINAL_ASSETS_DIR}/scenes/Scene1Prologue0.xml)
 

src/dawnshared/display/font/truetype/NewTrueTypeShared.hpp

@@ -0,0 +1,13 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "util/flag.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)

src/dawnshared/util/flag.hpp

@@ -4,7 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawnlibs.hpp"
+#include "dawnsharedlibs.hpp"
 
 typedef uint_fast8_t flag8_t;
 typedef uint_fast16_t flag16_t;

src/dawntools/CMakeLists.txt

@@ -26,4 +26,5 @@ add_subdirectory(prefabtool)
 add_subdirectory(scenetool)
 add_subdirectory(texturetool)
 add_subdirectory(truetypetool)
-add_subdirectory(vnscenetool)
+add_subdirectory(vnscenetool)
+add_subdirectory(newtruetypetool)

src/dawntools/newtruetypetool/CMakeLists.txt

@@ -0,0 +1,70 @@
+# Copyright (c) 2023 Dominic Msters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+project(newtruetypetool VERSION 3.0)
+add_executable(newtruetypetool)
+
+target_sources(newtruetypetool
+  PRIVATE
+    ${DAWN_SHARED_SOURCES}
+    ${DAWN_TOOL_SOURCES}
+    NewTrueTypeTool.cpp
+)
+
+target_include_directories(newtruetypetool
+  PUBLIC
+    ${DAWN_SHARED_INCLUDES}
+    ${DAWN_TOOL_INCLUDES}
+    ${CMAKE_CURRENT_LIST_DIR}
+)
+
+# Definitions
+target_compile_definitions(newtruetypetool
+  PUBLIC
+    ${DAWN_SHARED_DEFINITIONS}
+    DAWN_TOOL_INSTANCE=NewTrueTypeTool
+    DAWN_TOOL_HEADER="NewTrueTypeTool.hpp"
+)
+
+# Libraries
+target_link_libraries(newtruetypetool
+  PUBLIC
+    ${DAWN_BUILD_HOST_LIBS}
+)
+
+# Tool Function
+function(tool_newtruetype target)
+  # Defaults
+  set(FILE "" )
+
+  # Parse Args
+  foreach(_PAIR IN LISTS ARGN)
+    if (_PAIR MATCHES "^([^:]+)=(.*)$")
+      set(${CMAKE_MATCH_1} ${CMAKE_MATCH_2})
+    else()
+      message(FATAL_ERROR "Invalid pair: ${_PAIR}")
+    endif()
+  endforeach()
+
+  # Check for missing args
+
+  set(DEPS "")
+  if(DAWN_BUILD_TOOLS)
+    set(DEPS truetypetool)
+  endif()
+
+
+  add_custom_target(${target}
+    COMMAND newtruetypetool
+      --output="${DAWN_ASSETS_BUILD_DIR}/${target}.newtruetype"
+      --regular="${REGULAR}"
+      --bold="${BOLD}"
+      --italics="${ITALICS}"
+      --bold-italics="${BOLD_ITALICS}"
+    COMMENT "Generating newtruetype"
+    DEPENDS ${DEPS}
+  )
+  add_dependencies(${DAWN_TARGET_NAME} ${target})
+endfunction()

src/dawntools/newtruetypetool/NewTrueTypeTool.cpp

@@ -0,0 +1,160 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "NewTrueTypeTool.hpp"
+
+using namespace Dawn;
+
+NewTrueTypeFile::NewTrueTypeFile(std::string path) : file(path) {
+  this->path = path;
+
+  style = 0;
+  if(path.find("bold") != std::string::npos) {
+    style |= NEW_TRUETYPE_VARIANT_BOLD;
+  }
+  if(path.find("italics") != std::string::npos) {
+    style |= NEW_TRUETYPE_VARIANT_ITALICS;
+  }
+
+  if(!file.exists()) {
+    std::cout << "File " << path << " does not exist!" << std::endl;
+    throw "File not found";
+  }
+
+  if(!file.open(FILE_MODE_READ)) {
+    std::cout << "Failed to open file " << path << " for reading!" << std::endl;
+    throw "Unable to open file for reading!";
+  }
+}
+
+NewTrueTypeFile::~NewTrueTypeFile() {
+}
+
+
+std::vector<std::string> NewTrueTypeTool::getRequiredFlags() {
+  return { "output" };
+}
+
+std::map<std::string, std::string> NewTrueTypeTool::getOptionalFlags() {
+  return {
+    { "regular", "" },
+    { "italics", "" },
+    { "bold", "" },
+    { "bold-italics", "" }
+  };
+}
+
+int32_t NewTrueTypeTool::start() {
+  std::vector<NewTrueTypeFile*> files;
+  std::vector<std::string> flags = { "regular", "italics", "bold", "bold-italics" };
+
+  auto cleanupFiles = [&]() {
+    auto itFile = files.begin();
+    while(itFile != files.end()) {
+      auto file = *itFile;
+      delete file;
+      ++itFile;
+    }
+  };
+
+  // For each flag
+  auto itFlag = flags.begin();
+  while(itFlag != flags.end()) {
+    std::string flag = *itFlag;
+    std::string path = this->flags[flag];
+
+    if(path.empty()) {
+      ++itFlag;
+      continue;
+    }
+
+    try {
+      auto n = new NewTrueTypeFile(path);
+      files.push_back(n);
+    } catch(const char *e) {
+      cleanupFiles();
+      return 1;
+    }
+    std::cout << "Push back" << std::endl;
+    ++itFlag;
+  }
+
+  if(files.size() == 0) {
+    std::cout << "No valid TTF files provided!" << std::endl;
+    cleanupFiles();
+    return 1;
+  }
+
+  // Create the output file
+  File fileOut = File(this->flags["output"]);
+  if(!fileOut.mkdirp()) {
+    std::cout << "Failed to create output directory!" << std::endl;
+    cleanupFiles();
+    return 1;
+  }
+  if(!fileOut.open(FILE_MODE_WRITE)) {
+    std::cout << "Failed to open output file for writing!" << std::endl;
+    cleanupFiles();
+    return 1;
+  }
+  
+  // Prepare to write data
+  std::string header = "DE_TTF|3.00|";
+
+  // Write file count
+  header += std::to_string(files.size()) + "|";
+  
+  // For each file
+  auto itFile = files.begin();
+  while(itFile != files.end()) {
+    auto file = *itFile;
+    // Style
+    header += std::to_string(file->style);
+    header += ":";
+    // File length
+    header += std::to_string(file->file.length);
+    header += "|";
+    ++itFile;
+  }
+
+  if(!fileOut.writeRaw((char *)header.c_str(), header.length())) {
+    std::cout << "Failed to write TTF Header to " << fileOut.filename << std::endl;
+    cleanupFiles();
+    return 1;
+  }
+
+  // Now write the data for each file
+  itFile = files.begin();
+  while(itFile != files.end()) {
+    auto file = *itFile;
+
+    // Write the file data
+    file->file.setPosition(0);
+    if(!fileOut.copyRaw(&file->file, file->file.length)) {
+      std::cout << "Failed copy output data of " << file->file.filename << std::endl;
+      cleanupFiles();
+      return 1;
+    }
+
+    // Write vertical bar
+    char sep[1];
+    sep[0] = '|';
+    fileOut.writeRaw(sep, 1);
+
+    ++itFile;
+  }
+
+  // Cleanup
+  itFile = files.begin();
+  while(itFile != files.end()) {
+    auto file = *itFile;
+    delete file;
+    ++itFile;
+  }
+
+  // Done
+  fileOut.close();
+  return 0;
+}

src/dawntools/newtruetypetool/NewTrueTypeTool.hpp

@@ -0,0 +1,30 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "util/DawnTool.hpp"
+#include "util/File.hpp"
+#include "display/font/truetype/NewTrueTypeShared.hpp"
+
+namespace Dawn {
+  class NewTrueTypeFile {
+    public:
+      flag_t style;
+      std::string path;
+      File file;
+
+      NewTrueTypeFile(std::string path);
+      ~NewTrueTypeFile();
+  };
+
+  class NewTrueTypeTool : public DawnTool {
+    protected:
+      std::vector<std::string> getRequiredFlags() override;
+      std::map<std::string, std::string> getOptionalFlags() override;
+
+    public:
+      int32_t start();
+  };
+}

src/dawntools/util/File.cpp

@@ -178,6 +178,16 @@ size_t File::readToBuffer(char **buffer) {
   return l;
 }
 
+size_t File::readRaw(char *buffer, size_t max) {
+  assertNotNull(buffer);
+  assertTrue(max > 0);
+  if(!this->isOpen()) {
+    if(!this->open(FILE_MODE_READ)) return 0;
+  }
+  assertTrue(this->mode == FILE_MODE_READ);
+  return fread(buffer, sizeof(char), max, this->file);
+}
+
 bool_t File::writeString(std::string in) {
   if(!this->isOpen() && !this->open(FILE_MODE_WRITE)) return false;
   assertTrue(this->mode == FILE_MODE_WRITE);
@@ -187,10 +197,30 @@ bool_t File::writeString(std::string in) {
 bool_t File::writeRaw(char *data, size_t len) {
   if(!this->isOpen() && !this->open(FILE_MODE_WRITE)) return false;
   assertTrue(this->mode == FILE_MODE_WRITE);
+  assertTrue(len > 0);
   this->length = fwrite(data, sizeof(char_t), len, this->file);
   return true;
 }
 
+bool_t File::copyRaw(File *otherFile, size_t length) {
+  assertTrue(length > 0);
+  assertTrue(otherFile->isOpen());
+
+  char buffer[FILE_BUFFER_SIZE];
+  size_t amountLeftToRead = length;
+  size_t read = 0;
+  while(amountLeftToRead > 0) {
+    auto iRead = otherFile->readRaw(buffer, mathMin<size_t>(FILE_BUFFER_SIZE, amountLeftToRead));
+    if(iRead == 0) return false;
+    this->writeRaw(buffer, iRead);
+    amountLeftToRead -= iRead;
+    read += iRead;
+  }
+
+  assertTrue(read == length);
+  return true;
+}
+
 void File::setPosition(size_t n) {
   fseek(this->file, 0, SEEK_SET);
   fseek(this->file, n, SEEK_CUR);

src/dawntools/util/File.hpp

@@ -118,6 +118,15 @@ namespace Dawn {
        */
       size_t readToBuffer(char **buffer);
 
+      /**
+       * Reads the contents of this file into a given buffer. 
+       * 
+       * @param buffer Pointer to buffer to read to.
+       * @param max Max length of the buffer.
+       * @return Amount of bytes read.
+       */
+      size_t readRaw(char *buffer, size_t max);
+
       /**
        * Writes the entire contents of a string to a file.
        * 
@@ -130,9 +139,19 @@ namespace Dawn {
        * Write raw bytes to the file.
        * 
        * @param data Data to write.
+       * @param size Size of the data to write.
        * @return True if written successfully, otherwise false.
        */
-      bool_t writeRaw(char *data, size_t );
+      bool_t writeRaw(char *data, size_t size);
+
+      /**
+       * Write raw bytes to the file from another file.
+       * 
+       * @param otherFile Other file to read from.
+       * @param length Length of the data to read.
+       * @return True if written successfully, otherwise false.
+       */
+      bool_t copyRaw(File *otherFile, size_t length);
 
       /**
        * Set the position of the cursor of the file reader.