Fixed dynamic resizing issue for font

Author: Raelr

engine/render/renderer/platform/vulkan/Font.cpp

@@ -12,48 +12,41 @@
 #include <utils/Defer.h>
 #include <utils/Logging.h>
 
-#include "Context.h"
 #include "render/renderer/statics/Statics.h"
 #include "utils/Descriptor.h"
 #include "utils/TypeAdaptor.h"
 
+#define CAST_F(val) static_cast<float>(val)
+
 namespace Siege::Vulkan
 {
 Font::Font(const char* filePath)
 {
-    auto device = Context::GetCurrentDevice();
+    FT_Face fontFace;
 
-    auto ft = Statics::GetFontLib();
+    CC_ASSERT(!FT_New_Face(Statics::GetFontLib(), filePath, 0, &fontFace), "Failed to load font!")
 
-    FT_Face fontFace;
+    FT_Set_Pixel_Sizes(fontFace, 0, 64);
 
-    CC_ASSERT(!FT_New_Face(ft, filePath, 0, &fontFace), "Failed to load font!")
+    Utils::Offset2D textPadding = {1, 2};
 
-    uint8_t* buffer = new uint8_t[width * height];
+    uint8_t* buffer = new uint8_t[MAX_ATLAS_WIDTH * MAX_ATLAS_HEIGHT];
     defer([buffer]() { delete[] buffer; });
+    memset(buffer, 0, sizeof(uint8_t) * MAX_ATLAS_WIDTH * MAX_ATLAS_HEIGHT);
 
-    memset(buffer, 0, sizeof(uint8_t) * width * height);
+    extent = PopulateGlyphs(fontFace, textPadding, buffer);
 
     texture = Texture2D(filePath,
                         buffer,
-                        sizeof(uint8_t) * width * height,
-                        width,
-                        height,
+                        sizeof(uint8_t) * extent.width * extent.height,
+                        extent.width,
+                        extent.height,
                         Texture2D::Usage::TEX_USAGE_FONT);
 
-    VkSamplerCreateInfo samplerInfo =
-        Utils::Descriptor::SamplerCreateInfo(VK_FILTER_LINEAR,
-                                             VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE);
-
-    vkCreateSampler(device->GetDevice(), &samplerInfo, nullptr, &info.sampler);
+    PopulateTextureAtlas(buffer);
 
     id = INTERN_STR(filePath);
 
-    for (size_t i = 32; i < 126; i++)
-    {
-        AddChar(static_cast<unsigned char>(i), fontFace);
-    }
-
     info.textureInfo = texture.GetInfo();
 }
 
@@ -64,102 +57,102 @@ Font::~Font()
 
 void Font::Free()
 {
-    auto device = Context::GetVkLogicalDevice();
-
-    if (device == nullptr) return;
-
-    vkDestroySampler(device, info.sampler, nullptr);
-
     texture.Free();
 
-    info = {{}, nullptr};
+    info = {{}};
 }
 
 void Font::Swap(Font& other)
 {
     auto tmpId = id;
-    auto tmpWidth = width;
-    auto tmpHeight = height;
+    auto tmpAtlasExtent = extent;
     auto tmpGlyphs = glyphs;
-    auto tmpSpaceFilledX = spaceFilledX;
-    auto tmpSpaceFilledY = spaceFilledY;
-    auto tmpMaxHeight = maxHeight;
     auto tmpInfo = info;
     auto tmpTexture = std::move(texture);
 
     id = other.id;
-    width = other.width;
-    height = other.height;
-    spaceFilledX = other.spaceFilledX;
-    spaceFilledY = other.spaceFilledY;
-    maxHeight = other.maxHeight;
+    extent = other.extent;
     glyphs = other.glyphs;
     info = other.info;
     texture = std::move(other.texture);
 
     other.id = tmpId;
-    other.width = tmpWidth;
-    other.height = tmpHeight;
-    other.spaceFilledX = tmpSpaceFilledX;
-    other.spaceFilledY = tmpSpaceFilledY;
-    other.maxHeight = tmpMaxHeight;
+    other.extent = tmpAtlasExtent;
     other.glyphs = tmpGlyphs;
     other.info = tmpInfo;
     other.texture = std::move(tmpTexture);
 }
 
-void Font::AddChar(const unsigned char c, FontFace fontFace)
+Utils::Extent2D Font::PopulateGlyphs(FontFace fontFace, Utils::Offset2D padding, uint8_t* buffer)
 {
-    FT_Set_Pixel_Sizes(fontFace, 0, 64);
+    float x {0.f}, y {0.f}, rowHeight {0.f}, maxX {0.f}, maxY {0.f};
 
-    CC_ASSERT(!FT_Load_Char(fontFace, c, FT_LOAD_RENDER),
-              String("Unable to load char: ") + String(c))
+    uint32_t offset {0};
 
-    auto glyph = fontFace->glyph;
+    for (unsigned char c = 32; c < 126; c++)
+    {
+        auto message = String("Unable to load char: ") + String(c);
+        CC_ASSERT(!FT_Load_Char(fontFace, c, FT_LOAD_RENDER), message.Str())
+
+        auto glyph = fontFace->glyph;
 
-    bool exceededWidth = (glyph->bitmap.width + spaceFilledX) >= width;
-    bool exceededHeight = (glyph->bitmap.rows + spaceFilledY) >= height;
+        uint32_t width {glyph->bitmap.width}, height {glyph->bitmap.rows};
 
-    int32_t positionXInAtlas = (spaceFilledX) * !exceededWidth;
-    int32_t positionYInAtlas = spaceFilledY + static_cast<int32_t>(exceededWidth * maxHeight);
+        bool exceededWidth = (width + x) >= MAX_ATLAS_WIDTH;
 
-    unsigned long size = glyph->bitmap.width * glyph->bitmap.rows;
+        float atlasX = x * !exceededWidth;
+        float atlasY = y + (exceededWidth * rowHeight);
 
-    glyphs[c] = {
-        static_cast<float>(static_cast<float>(positionXInAtlas + 1) / static_cast<float>(width)),
-        static_cast<float>(static_cast<float>(positionYInAtlas + 2) / static_cast<float>(height)),
-        static_cast<float>(static_cast<float>(glyph->bitmap.width + positionXInAtlas + 1) /
-                           static_cast<float>(width)),
-        static_cast<float>(static_cast<float>(glyph->bitmap.rows + positionYInAtlas + 2) /
-                           static_cast<float>(height)),
-        static_cast<float>(glyph->bitmap.width),
-        static_cast<float>(glyph->bitmap.rows),
-        static_cast<float>(glyph->bitmap.width) / static_cast<float>(width),
-        static_cast<float>(glyph->bitmap.rows) / static_cast<float>(height),
-        static_cast<float>(glyph->bitmap_left),
-        static_cast<float>(glyph->bitmap_top),
-        static_cast<unsigned int>(glyph->advance.x)};
+        glyphs[c] = {atlasX + padding.width,
+                     atlasY + padding.height,
+                     CAST_F(width),
+                     CAST_F(height),
+                     CAST_F(width),
+                     CAST_F(height),
+                     CAST_F(glyph->bitmap_left),
+                     CAST_F(glyph->bitmap_top),
+                     glyph->advance.x,
+                     offset};
 
-    if (size == 0) return;
+        rowHeight = (height > rowHeight) * height + (height <= rowHeight) * rowHeight;
 
-    Utils::Extent3D imageExtent {static_cast<uint32_t>(glyph->bitmap.width),
-                                 static_cast<uint32_t>(glyph->bitmap.rows),
-                                 1};
+        x = ((!exceededWidth * (width + x)) + (exceededWidth * width)) + padding.width;
+        y += (exceededWidth * (rowHeight + padding.height));
 
-    texture.CopyToRegion(glyph->bitmap.buffer,
-                         size,
-                         imageExtent,
-                         {positionXInAtlas + 1, positionYInAtlas + 2});
+        maxX = (x > maxX) * x + (x <= maxX) * maxX;
+        maxY = (y > maxY) * (y + rowHeight + padding.height) + (y <= maxY) * maxY;
 
-    CC_ASSERT(!exceededWidth || !exceededHeight, "Cannot add any more images to the atlas!")
+        auto size = sizeof(uint8_t) * width * height;
 
-    maxHeight = ((glyph->bitmap.rows > maxHeight) * glyph->bitmap.rows) +
-                ((glyph->bitmap.rows <= maxHeight) * maxHeight);
+        memcpy(buffer + offset, glyph->bitmap.buffer, size);
+        offset += size;
+    }
 
-    spaceFilledX = ((!exceededWidth * (glyph->bitmap.width + spaceFilledX)) +
-                    (exceededWidth * glyph->bitmap.width)) +
-                   1;
-    spaceFilledY += (exceededWidth * (maxHeight + 2));
+    return {(uint32_t) maxX + padding.width, (uint32_t) maxY + padding.height};
 }
 
+void Font::PopulateTextureAtlas(uint8_t* buffer)
+{
+    for (unsigned char c = 32; c < 126; c++)
+    {
+        auto& glyph = glyphs[c];
+        float xPos {glyph.uvxMin}, yPos {glyph.uvyMin};
+
+        glyph.uvxMin /= CAST_F(extent.width);
+        glyph.uvyMin /= CAST_F(extent.height);
+
+        glyph.widthNormalised /= CAST_F(extent.width);
+        glyph.heightNormalised /= CAST_F(extent.height);
+
+        Utils::Extent3D imageExtent {(uint32_t) glyph.width, (uint32_t) glyph.height, 1};
+
+        size_t size = sizeof(uint8_t) * glyph.width * glyph.height;
+        if (size == 0) continue;
+
+        texture.CopyToRegion(buffer + glyph.bufferOffset,
+                             size,
+                             imageExtent,
+                             {int32_t(xPos), int32_t(yPos)});
+    }
+}
 } // namespace Siege::Vulkan

engine/render/renderer/platform/vulkan/Font.h

@@ -29,10 +29,6 @@ class Font
 {
 public:
 
-    // Constexpr declarations
-    static constexpr uint32_t INITIAL_FONT_ATLAS_WIDTH {512};
-    static constexpr uint32_t INITIAL_FONT_ATLAS_HEIGHT {512};
-
     // Structs
 
     /**
@@ -41,7 +37,6 @@ class Font
     struct Info
     {
         Texture2D::Info textureInfo {};
-        VkSampler sampler {nullptr};
     };
 
     /**
@@ -53,15 +48,14 @@ class Font
     {
         float uvxMin {0};
         float uvyMin {0};
-        float uvxMax {0};
-        float uvyMax {0};
         float width {0};
         float height {0};
         float widthNormalised {0};
         float heightNormalised {0};
         float bearingX {0};
         float bearingY {0};
-        unsigned int advance {0};
+        signed long advance {0};
+        unsigned long bufferOffset {0};
     };
 
     // 'Structors
@@ -153,27 +147,34 @@ class Font
 
 private:
 
+    // Constexpr declarations
+    static constexpr uint32_t MAX_ATLAS_WIDTH {512};
+    static constexpr uint32_t MAX_ATLAS_HEIGHT {1024};
+
     /**
      * Swaps the values of two Fonts
      * @param other the Font to swap values with
      */
     void Swap(Font& other);
 
     /**
-     * Adds a character glyph to the font atlas
-     * @param c the character to add
+     * Populates the font with all glyphs stored in the ttf file
+     * @param fontFace the font face used to render the characters
+     * @param padding padding between the characters in the font
+     * @param buffer a buffer of pixels to copy data from the font face into
+     * @return the width and height of the texture
      */
-    void AddChar(const unsigned char c, FontFace fontFace);
-
-    uint32_t width {INITIAL_FONT_ATLAS_WIDTH};
-    uint32_t height {INITIAL_FONT_ATLAS_HEIGHT};
+    Utils::Extent2D PopulateGlyphs(FontFace fontFace, Utils::Offset2D padding, uint8_t* buffer);
 
-    SArray<Glyph, 256> glyphs;
+    /**
+     * Populates the texture atlas with the glyphs collected from PopulateGlyphs
+     * @param buffer the pixel buffer storing our glyph pixels
+     */
+    void PopulateTextureAtlas(uint8_t* buffer);
 
-    int32_t spaceFilledX {0};
-    int32_t spaceFilledY {0};
+    Utils::Extent2D extent {};
 
-    uint32_t maxHeight {0};
+    SArray<Glyph, 256> glyphs;
 
     Hash::StringId id {0};
     Texture2D texture;

engine/render/renderer/platform/vulkan/LogicalDevice.cpp

@@ -80,6 +80,7 @@ LogicalDevice::LogicalDevice(const Surface& surface, PhysicalDevice& physDevice)
     GET_UNIQUE_QUEUES(queueCreateInfos, graphicsIdx, presentIdx)
 
     auto deviceExtensions = Vulkan::Config::deviceExtensions;
+    auto layers = Vulkan::Config::validationLayers;
 
     CREATE_LOGICAL_DEVICE(
         vkPhysicalDevice,

engine/render/renderer/platform/vulkan/utils/Types.h

@@ -213,6 +213,12 @@ struct Offset3D
     int32_t depth {0};
 };
 
+struct Offset2D
+{
+    int32_t width {0};
+    int32_t height {0};
+};
+
 struct Image2DConfig
 {
     ImageFormat format;

engine/utils/collections/HeapArray.h

@@ -315,7 +315,6 @@ class MHArray
     void Clear()
     {
         count = 0;
-        memset(data, 0, sizeof(T) * size);
         bitField.Clear();
     }