Refactoring basic text rendering

src/Engine/Asset/FontAsset.cpp

@@ -1,7 +1,6 @@
 #include "FontAsset.h"
 #include "Graphics/Graphics.h"
 #include "Graphics/Texture.h"
-#include <ktx.h>
 
 using namespace Seele;
 
@@ -11,106 +10,31 @@ FontAsset::FontAsset(std::string_view folderPath, std::string_view name) : Asset
 
 FontAsset::~FontAsset() {}
 
-void FontAsset::save(ArchiveBuffer& buffer) const {
-    Serialization::save(buffer, glyphs);
-    Serialization::save(buffer, usedTextures.size());
-    for (uint32 x = 0; x < usedTextures.size(); ++x) {
-        Array<uint8> textureData;
-        ktxTexture2* kTexture;
-        ktxTextureCreateInfo createInfo = {
-            .glInternalformat = 0,
-            .vkFormat = (uint32_t)usedTextures[x]->getFormat(),
-            .pDfd = nullptr,
-            .baseWidth = usedTextures[x]->getWidth(),
-            .baseHeight = usedTextures[x]->getHeight(),
-            .baseDepth = usedTextures[x]->getDepth(),
-            .numDimensions = usedTextures[x]->getDepth() > 1    ? 3u
-                             : usedTextures[x]->getHeight() > 1 ? 2u
-                                                                : 1u,
-            .numLevels = usedTextures[x]->getMipLevels(),
-            .numLayers = usedTextures[x]->getDepth(),
-            .numFaces = usedTextures[x]->getNumFaces(),
-            .isArray = false,
-            .generateMipmaps = false,
-        };
-        ktxTexture2_Create(&createInfo, KTX_TEXTURE_CREATE_ALLOC_STORAGE, &kTexture);
+void FontAsset::save(ArchiveBuffer& buffer) const { Serialization::save(buffer, glyphs); }
 
-        for (uint32 depth = 0; depth < usedTextures[x]->getDepth(); ++depth) {
-            for (uint32 face = 0; face < usedTextures[x]->getNumFaces(); ++face) {
-                // technically, downloading cant be const, because we have to allocate temporary buffers and change layouts
-                // but practically the texture stays the same
-                const_cast<Gfx::Texture2D*>(*(usedTextures[x]))->download(0, depth, face, textureData);
-                ktxTexture_SetImageFromMemory(ktxTexture(kTexture), 0, depth, face, textureData.data(), textureData.size());
-            }
-        }
-        char writer[100];
-        snprintf(writer, sizeof(writer), "%s version %s", "SeeleEngine", "0.0.1");
-        ktxHashList_AddKVPair(&kTexture->kvDataHead, KTX_WRITER_KEY, (ktx_uint32_t)strlen(writer) + 1, writer);
-
-        ktxTexture2_TranscodeBasis(kTexture, KTX_TTF_ASTC_4x4_RGBA, 0);
-
-        ktx_uint8_t* texData;
-        ktx_size_t texSize;
-        ktxTexture_WriteToMemory(ktxTexture(kTexture), &texData, &texSize);
-
-        Array<uint8> rawData(texSize);
-        std::memcpy(rawData.data(), texData, texSize);
-
-        free(texData);
-
-        Serialization::save(buffer, rawData);
-    }
-}
-
-void FontAsset::load(ArchiveBuffer& buffer) {
-    Serialization::load(buffer, glyphs);
-    size_t numTextures;
-    Serialization::load(buffer, numTextures);
-    for (uint64 x = 0; x < numTextures; ++x) {
-        Array<uint8> rawTex;
-        Serialization::load(buffer, rawTex);
-
-        ktxTexture2* kTexture;
-        ktxTexture2_CreateFromMemory(rawTex.data(), rawTex.size(), KTX_TEXTURE_CREATE_LOAD_IMAGE_DATA_BIT, &kTexture);
-
-        ktxTexture2_TranscodeBasis(kTexture, KTX_TTF_BC7_RGBA, 0);
-
-        TextureCreateInfo createInfo = {
-            .sourceData =
-                {
-                    .size = ktxTexture_GetDataSize(ktxTexture(kTexture)),
-                    .data = ktxTexture_GetData(ktxTexture(kTexture)),
-                    .owner = Gfx::QueueType::GRAPHICS,
-                },
-            .format = (Gfx::SeFormat)kTexture->vkFormat,
-            .width = kTexture->baseWidth,
-            .height = kTexture->baseHeight,
-            .depth = kTexture->baseDepth,
-            .layers = kTexture->numFaces,
-            .elements = kTexture->numLayers,
-            .useMip = true,
-            .usage = Gfx::SE_IMAGE_USAGE_SAMPLED_BIT,
-        };
-
-        Gfx::OTexture2D texture = buffer.getGraphics()->createTexture2D(createInfo);
-        usedTextures.add(std::move(texture));
-
-        ktxTexture_Destroy(ktxTexture(kTexture));
-    }
-}
-
-void Seele::FontAsset::setUsedTextures(Array<Gfx::OTexture2D> _usedTextures) { usedTextures = std::move(_usedTextures); }
+void FontAsset::load(ArchiveBuffer& buffer) { Serialization::load(buffer, glyphs); }
 
 void FontAsset::Glyph::save(ArchiveBuffer& buffer) const {
-    Serialization::save(buffer, textureIndex);
     Serialization::save(buffer, size);
     Serialization::save(buffer, bearing);
     Serialization::save(buffer, advance);
+    Serialization::save(buffer, textureData);
 }
 
 void FontAsset::Glyph::load(ArchiveBuffer& buffer) {
-    Serialization::load(buffer, textureIndex);
     Serialization::load(buffer, size);
     Serialization::load(buffer, bearing);
     Serialization::load(buffer, advance);
+    Serialization::load(buffer, textureData);
+    texture = buffer.getGraphics()->createTexture2D(TextureCreateInfo{
+        .sourceData =
+            {
+                .size = textureData.size(),
+                .data = textureData.data(),
+            },
+        .format = Gfx::SE_FORMAT_R8_UNORM,
+        .width = size.x,
+        .height = size.y,
+        .name = "FontGlyph",
+    });
 }

src/Engine/Asset/FontAsset.h

@@ -2,6 +2,7 @@
 #include "Asset.h"
 #include "Containers/Map.h"
 #include "Math/Math.h"
+#include <freetype/freetype.h>
 
 namespace Seele {
 DECLARE_NAME_REF(Gfx, Texture2D)
@@ -15,19 +16,17 @@ class FontAsset : public Asset {
     virtual void load(ArchiveBuffer& buffer) override;
 
     struct Glyph {
-        uint32 textureIndex;
-        IVector2 size;
-        IVector2 bearing;
-        uint32 advance;
+        UVector2 size = {};
+        UVector2 bearing = {};
+        uint32 advance = 0;
+        Array<uint8> textureData;
+        Gfx::OTexture2D texture = nullptr;
         void save(ArchiveBuffer& buffer) const;
         void load(ArchiveBuffer& buffer);
     };
-    const Map<uint32, Glyph> getGlyphData() const { return glyphs; }
-    Gfx::PTexture2D getTexture(uint32 index) { return usedTextures[index]; }
-    void setUsedTextures(Array<Gfx::OTexture2D> _usedTextures);
+    const Glyph& getGlyphData(char c) const { return glyphs[c]; }
 
   private:
-    Array<Gfx::OTexture2D> usedTextures;
     Map<uint32, Glyph> glyphs;
     friend class FontLoader;
 };

src/Engine/Asset/MeshAsset.cpp

@@ -3,7 +3,6 @@
 #include "Graphics/Graphics.h"
 #include "Graphics/Mesh.h"
 
-
 using namespace Seele;
 
 MeshAsset::MeshAsset() {}
@@ -14,7 +13,8 @@ MeshAsset::~MeshAsset() {}
 
 void MeshAsset::save(ArchiveBuffer& buffer) const { Serialization::save(buffer, meshes); }
 
-void MeshAsset::load(ArchiveBuffer& buffer) { Serialization::load(buffer, meshes);
+void MeshAsset::load(ArchiveBuffer& buffer) {
+    Serialization::load(buffer, meshes);
     byteSize = 0;
     for (const auto& mesh : meshes) {
         byteSize += mesh->getCPUSize();