Improve font rendering and add batch binary file reading

UntitledOutput · UntitledOutput · commit 2b406cb9bcc7 · 2025-12-17T21:42:18.000-05:00
Refactored font character geometry to use floating point vectors for size and bearing, and improved transform calculations for UI elements and text rendering. Added a new IoEngine::readFilesBinary method for batch reading binary files from a directory. Updated SMD animation loader for better performance and correctness. Minor shader and debug improvements, and updated GLFW submodule.
diff --git a/default_assets/shaders/defaultui.glsl b/default_assets/shaders/defaultui.glsl
@@ -14,7 +14,11 @@ void main()
 
    texCoords.y = 1.0 - texCoords.y;
 
-   gl_Position = _internalProj * _internalModel * vec4(aPos,0, 1.0);
+   vec4  p = _internalProj * _internalModel * vec4(aPos,0, 1.0);
+
+   p.z = 0;
+
+   gl_Position = p;
 }
 #define __ENDSHADER
 
diff --git a/ext/glfw b/ext/glfw
@@ -1 +1 @@
-Subproject commit 162896e5b9a40dc382c5c438cd12c90a5ff86ddd
+Subproject commit 3b30a4ce798b84e96a452a8edcded44c49843254
diff --git a/include/borealis/gfx/ui.hpp b/include/borealis/gfx/ui.hpp
@@ -35,13 +35,14 @@ namespace brl
         void earlyUpdate() override;
         void lateUpdate() override;
 
+                static GfxCanvas* mainCanvas;
+
     private:
         friend struct GfxImage;
         friend struct GfxUIElement;
         friend struct GfxTextRenderer;
         friend GfxEngine;
 
-        static GfxCanvas* mainCanvas;
 
         void insertDrawCall(const GfxUIDrawCall call);
 
@@ -129,9 +130,9 @@ namespace brl
         struct GfxFontCharacter : GfxTexture
         {
             GfxFontCharacter() = default;
-            GfxFontCharacter(unsigned int id, glm::ivec2 s, glm::ivec2 b, unsigned int adv);
-            glm::ivec2 size; // Size of glyph
-            glm::ivec2 bearing; // Offset from baseline to left/top of glyph
+            GfxFontCharacter(unsigned int id, glm::vec2 s, glm::vec2 b, unsigned int adv);
+            glm::vec2 size; // Size of glyph
+            glm::vec2 bearing; // Offset from baseline to left/top of glyph
             unsigned int advanceOffset; // Offset to advance to next glyph
 
             GfxAttribBuffer* charVAO = nullptr;
@@ -154,6 +155,7 @@ namespace brl
         std::string text;
 
         void start() override;
+        void debugPrintCharacterInfo();
         void lateUpdate() override;
 
     private:
diff --git a/include/borealis/util/io.h b/include/borealis/util/io.h
@@ -38,6 +38,7 @@ namespace brl
         void print(std::string s);
         IoFile readFileBinary(std::string path);
         std::string readFileString(std::string path);
+        std::vector<IoFile> readFilesBinary(std::string directory);
         void shutdown();
     };
 
@@ -47,6 +48,10 @@ namespace brl
     {
         return IoEngine::engine->readFileString(path);
     }
+    inline std::vector<IoFile> readFilesBinary(std::string directory)
+    {
+        return IoEngine::engine->readFilesBinary(directory);  
+    }
 
 
 } // namespace brl
diff --git a/src/brl/gfx/model.cpp b/src/brl/gfx/model.cpp
@@ -8,6 +8,7 @@
 #include "borealis/debug/debug.hpp"
 #include "borealis/gfx/engine.hpp"
 #include "borealis/gfx/shader.hpp"
+#include "glm/gtx/euler_angles.hpp"
 #include "glm/gtx/matrix_decompose.hpp"
 
 static brl::GfxShaderProgram* defaultSkinningShader = nullptr;
@@ -104,6 +105,9 @@ brl::GfxShaderProgram* GetSkinningShader()
     return defaultSkinningShader;
 }
 
+std::map<std::string, brl::GfxAnimation*> brl::GfxAnimation::cachedAnimations;
+
+
 brl::GfxAnimation *brl::GfxAnimation::loadAnimation(std::string path)
 {
     if (cachedAnimations.contains(path))
@@ -132,53 +136,146 @@ std::vector<std::string> splitFileByCharacter(const std::string& data, char deli
 brl::GfxAnimation::GfxAnimation(std::string path)
 {
 
-    if (path.ends_with(".smd")) {
+if (path.ends_with(".smd"))
+    {
         // smd loading
-
         std::string data = brl::readFileString(path);
-
         const auto& lines = splitFileByCharacter(data);
 
-        int version = 0;
-
-        enum smd_stage {
+        enum smd_stage
+        {
             none,
-            nodes
+            nodes,
+            skeleton
         };
         smd_stage cur_stage = none;
 
-        for (const auto & line : lines) {
-            if (line.starts_with("version")) {
-                using namespace std::literals::string_literals; // Bring the "s" suffix into scope
+        struct smd_frame
+        {
+            int frame;
+            glm::vec3 position;
+            glm::quat rotation;
+        };
+
+        struct smd_channel
+        {
+            std::vector<smd_frame> frames;
+        };
+
+        struct smd_bone
+        {
+            int id = 0;
+            std::string name;
+            int parent_bone = -1;
+            smd_channel channel;
+        };
+
+        std::vector<smd_bone> bones;
+        bones.reserve(64); // Reserve reasonable initial capacity
 
-                std::string verStr = line.substr(("version "s).length(),1);
+        int max_frame = 0;
+        int current_time = 0;
 
-                version = std::atoi(verStr.c_str());
+        for (const auto& line : lines)
+        {
+            if (line.empty())
                 continue;
-            }
 
-            if (line.starts_with("nodes")) {
+            // Fast stage detection using first character
+            char first_char = line[0];
+
+            if (first_char == 'v')
+            { // version
+                continue; // Version not used, skip parsing
+            }
+            else if (first_char == 'n')
+            { // nodes
                 cur_stage = nodes;
                 continue;
             }
-
-            if (line.starts_with("end")) {
+            else if (first_char == 's')
+            { // skeleton
+                cur_stage = skeleton;
+                continue;
+            }
+            else if (first_char == 'e')
+            { // end
                 cur_stage = none;
                 continue;
             }
 
-            if (cur_stage == nodes) {
-                auto data = splitFileByCharacter(line,' ');
+            if (cur_stage == nodes)
+            {
+                auto data = splitFileByCharacter(line, ' ');
 
-                int id = std::atoi(data[0].c_str());
-                std::string name = data[1].c_str();
-                int parentId = std::atoi(data[2].c_str());
+                smd_bone bone;
+                bone.id = std::atoi(data[0].c_str());
+                bone.name = std::move(data[1]);
+                bone.parent_bone = std::atoi(data[2].c_str());
+                bone.channel.frames.reserve(max_frame > 0 ? max_frame + 1 : 32);
 
+                bones.push_back(std::move(bone));
+            }
+            else if (cur_stage == skeleton)
+            {
+                if (first_char == 't')
+                { // time
+                    // Fast parse: skip "time " prefix
+                    current_time = std::atoi(line.c_str() + 5);
+                    max_frame = std::max(max_frame, current_time);
+                }
+                else
+                {
+                    auto data = splitFileByCharacter(line, ' ');
+                    int id = std::atoi(data[0].c_str());
+
+                    smd_frame f;
+                    f.frame = current_time;
+                    f.position =
+                        glm::vec3(std::atof(data[1].c_str()), std::atof(data[2].c_str()), std::atof(data[3].c_str()));
+
+                    glm::vec3 angles(std::atof(data[4].c_str()), std::atof(data[5].c_str()),
+                                     std::atof(data[6].c_str()));
+
+                    // Correct SMD quaternion conversion (XYZ order)
+                    f.rotation = glm::quat(angles);
+
+                    bones[id].channel.frames.push_back(std::move(f));
+                }
             }
         }
 
-    }
+        length = 1.0f;
+
+        // Reserve space for channels
+        channels.reserve(bones.size() * 2);
+
+        const float inv_max_frame = max_frame > 0 ? 1.0f / static_cast<float>(max_frame) : 0.0f;
 
+        for (auto& bone : bones)
+        {
+            if (bone.channel.frames.empty())
+                continue;
+
+            Channel positionChannel{bone.id, ChannelInterpolation::LINEAR, TRANSLATION};
+            Channel rotationChannel{bone.id, ChannelInterpolation::LINEAR, ROTATION};
+
+            size_t frame_count = bone.channel.frames.size();
+            positionChannel.frames.reserve(frame_count);
+            rotationChannel.frames.reserve(frame_count);
+
+            for (const smd_frame& frame : bone.channel.frames)
+            {
+                float time = static_cast<float>(frame.frame) * inv_max_frame;
+
+                positionChannel.frames.push_back(new Vec3AnimationFrame{time, frame.position});
+                rotationChannel.frames.push_back(new QuatAnimationFrame{time, frame.rotation});
+            }
+
+            channels.push_back(std::move(positionChannel));
+            channels.push_back(std::move(rotationChannel));
+        }
+    }
 }
 
 brl::GfxSubMesh::~GfxSubMesh()
diff --git a/src/brl/gfx/ui.cpp b/src/brl/gfx/ui.cpp
diff --git a/src/brl/util/io.cpp b/src/brl/util/io.cpp
