Implement scalable UI system and update map logic

Introduces a scalable UI system with anchor, pivot, and scaling support in GfxCanvas and GfxUIElement, including new layout and transform logic. Refactors map and chunk logic to use new MAP_CHUNK_SIZE and MAP_BLOCK_SPACING constants, adds composite block offset calculation, and updates block/model handling for improved flexibility. Adds new UI assets and updates test code to use the new UI system.

Author: UntitledOutput

borealis.sln.DotSettings.user

@@ -0,0 +1,5 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/Housekeeping/Bookmarks/NumberedBookmarks/=Bookmark9/@KeyIndexDefined">True</s:Boolean>
+	<s:String x:Key="/Default/Housekeeping/Bookmarks/NumberedBookmarks/=Bookmark9/Coords/@EntryValue">(Doc Ln 124 Col 22)</s:String>
+	<s:String x:Key="/Default/Housekeeping/Bookmarks/NumberedBookmarks/=Bookmark9/FileId/@EntryValue">96ECAD5E-82B9-086A-ABD2-F61197FE3DF8/d:src/d:brl/d:gfx/f:ui.cpp</s:String>
+	<s:String x:Key="/Default/Housekeeping/Bookmarks/NumberedBookmarks/=Bookmark9/Owner/@EntryValue">NumberedBookmarkManager</s:String></wpf:ResourceDictionary>

include/borealis/ecs/entity.hpp

@@ -12,9 +12,9 @@ namespace brl
         glm::quat localRotation = glm::identity<glm::quat>();
         glm::vec3 localScale = glm::vec3(1.0);
 
-        glm::vec3 position();
+        virtual glm::vec3 position();
         glm::quat rotation();
-        glm::vec3 scale();
+        virtual glm::vec3 scale();
         void lookAt(glm::vec3 point, glm::vec3 up = glm::vec3{0,1,0});
         void setEulerAngles(glm::vec3 euler);
 
@@ -32,6 +32,10 @@ namespace brl
         template <typename T>
         T* getEntityInChildren();
 
+        
+        template <typename T>
+        T* getEntity();
+
         EcsEntity();
 
     protected:
@@ -49,7 +53,7 @@ namespace brl
 
         void internalDestroy();
 
-        glm::mat4 calculateTransform();
+        virtual glm::mat4 calculateTransform();
 
         std::vector<EcsEntity*> children;
         EcsEntity* parent = nullptr;
@@ -96,6 +100,12 @@ namespace brl
         return nullptr;
     }
 
+    template <typename T>
+    T* EcsEntity::getEntity()
+    {
+        return dynamic_cast<T*>(this);
+    }
+
     struct EcsEngine {
 
         EcsEngine();

include/borealis/gfx/engine.hpp

@@ -53,7 +53,7 @@ namespace brl
         void shutdown();
         void update();
         bool isRunning() {return mainWindow->isOpen();}
-        void insertCall(GfxMaterial* material, GfxAttribBuffer* buffer, const glm::mat4 transform, int instancingIdx = 0);
+        void insertCall(GfxMaterial* material, GfxAttribBuffer* buffer, const glm::mat4& transform, int instancingIdx = 0);
         int getFrameCount();
 
         float getAspectRatio();

include/borealis/gfx/ui.hpp

@@ -14,14 +14,29 @@ namespace brl
     {
 
         EcsCamera* targetedCamera = nullptr;
-        glm::vec2 scaledSize;
+
+        enum class ScaleMode
+        {
+            ConstantPixelSize,
+            ScaleWithScreenSize,
+            ConstantPhysicalSize
+        };
+
+        ScaleMode mode = ScaleMode::ScaleWithScreenSize;
+
+        glm::vec2 referenceResolution;
+        float referencePixelsPerUnit = 100.0f;
+        float referenceDPI = 96.0f;
+
+        float matchWidthOrHeight = 0.5;
 
         GfxCanvas();
         void earlyUpdate() override;
         void lateUpdate() override;
 
     private:
         friend struct GfxImage;
+        friend struct GfxUIElement;
         friend GfxEngine;
 
         static GfxCanvas* mainCanvas;
@@ -32,22 +47,120 @@ namespace brl
 
         void draw();
 
+        float GetScaleFactor(glm::vec2 screenResolution, float screenDPI = 96.0f)
+        {
+            switch (mode)
+            {
+                case ScaleMode::ConstantPixelSize:
+                    return 1.0f;
+
+                case ScaleMode::ScaleWithScreenSize:
+                    {
+                        float logWidth = std::log(screenResolution.x / referenceResolution.x);
+                        float logHeight = std::log(screenResolution.y / referenceResolution.y);
+                        float logScale = glm::mix(logWidth, logHeight, matchWidthOrHeight);
+                        return std::exp(logScale);
+                    }
+
+                case ScaleMode::ConstantPhysicalSize:
+                    return screenDPI / referenceDPI;
+            }
+            return 1.0f;
+        }
+
         std::vector<GfxUIDrawCall> draw_calls;
+
+        glm::vec2 ScaleUICoordinates(glm::vec2 uiPos, glm::vec2 screenResolution, float screenDPI = 96.0f)
+        {
+            float scale = GetScaleFactor(screenResolution, screenDPI);
+            return uiPos * scale;
+        }
+
+        glm::vec2 GetScaledCanvasSize(glm::vec2 screenResolution, float screenDPI = 96.0f)
+        {
+            float scale = GetScaleFactor(screenResolution, screenDPI);
+            return screenResolution / scale; // Returns virtual resolution
+        }
     };
 
-    struct GfxUIElement : EcsEntity
+    struct GfxUIRect
     {
-        GfxUIElement();
-        void start() override;
+        glm::vec2 position; // bottom-left corner
+        glm::vec2 size;
+    };
+
 
+    struct GfxUIElement : EcsEntity
+    {
+        GfxUIElement(GfxCanvas* c);
+
+        // Anchor positions (0-1 range, relative to parent)
+        glm::vec2 anchorMin = {0.5f, 0.5f}; // default: center
+        glm::vec2 anchorMax = {0.5f, 0.5f}; // default: center
+
+        // Offsets in pixels from anchors
+        glm::vec2 offsetMin = {-50, -50}; // left, bottom
+        glm::vec2 offsetMax = {50, 50}; // right, top
+
+        // Pivot point (0-1 range, local to this element)
+        glm::vec2 pivot = {0.5f, 0.5f}; // default: center
+
+        
+        GfxUIRect GetRect() const;
+        
+        glm::mat4 calculateTransform() override;
+
+        void SetPosition(glm::vec2 pos)
+        {
+            if (anchorMin == anchorMax)
+            {
+                glm::vec2 size = GetSize();
+                offsetMin = pos - size * pivot;
+                offsetMax = offsetMin + size;
+            }
+        }
+
+        void SetSize(glm::vec2 size)
+        {
+            if (anchorMin == anchorMax)
+            {
+                glm::vec2 pos = GetPosition();
+                offsetMin = pos - size * pivot;
+                offsetMax = offsetMin + size;
+            }
+        }
+
+        glm::vec2 GetPosition() const
+        {
+            GfxUIRect rect = GetRect();
+            return rect.position + rect.size * pivot;
+        }
+
+        glm::vec2 GetSize() const { return GetRect().size; }
+
+        glm::vec2 GetWorldPosition() const
+        {
+            glm::vec2 localPos = GetPosition();
+            if (parent && parent->getEntity<GfxUIElement>())
+            {
+                GfxUIRect parentRect = parent->getEntity<GfxUIElement>()->GetRect();
+                return parentRect.position + localPos;
+            }
+            return localPos;
+        }
 
     protected:
         GfxCanvas* canvas;
+
+
     };
 
     struct GfxImage : GfxUIElement
     {
-        GfxTexture2d* texture;
+        GfxImage(GfxCanvas* c);
+
+        glm::vec3 color = glm::vec3(1.0);
+        GfxTexture2d* texture = GfxTexture2d::getWhiteTexture();
         GfxMaterial* material = new GfxMaterial(new GfxShaderProgram(brl::readFileString("D:/shaders/defaultui.glsl")));
 
                 void lateUpdate() override;

src/brl/gfx/engine.cpp

@@ -1,5 +1,6 @@
 #include <thread>
 
+#include "stb_image.h"
 #include "borealis/gfx/ui.hpp"
 
 #include "borealis/gfx/gfx.hpp"
@@ -109,6 +110,9 @@ void brl::GfxEngine::initialize()
     instance = this;
     materialMgr = new GfxMaterialMgr;
 
+    stbi_set_flip_vertically_on_load(true);
+
+
     auto vertexShaderSource = "#version 330 core\n"
         "layout (location = 0) in vec2 aPos;\n"
         "layout (location = 1) in vec2 aUV;\n"
@@ -254,7 +258,7 @@ void brl::GfxEngine::update()
 
 }
 
-void brl::GfxEngine::insertCall(GfxMaterial* material, GfxAttribBuffer* buffer, const glm::mat4 transform,
+void brl::GfxEngine::insertCall(GfxMaterial* material, GfxAttribBuffer* buffer, const glm::mat4& transform,
                                 int instancingIdx)
 {
     auto shader = material->getShader();

src/brl/gfx/texture.cpp

@@ -31,7 +31,6 @@ brl::GfxTexture2d::GfxTexture2d(std::string path)
 
     IoFile file = readFileBinary(path);
 
-    stbi_set_flip_vertically_on_load(true);
 
     unsigned char* data = stbi_load_from_memory(file.data, file.dataSize, &width, &height, &nrChannels, 4);
 

src/brl/gfx/ui.cpp

@@ -9,7 +9,7 @@ brl::GfxCanvas::GfxCanvas()
     if (!mainCanvas)
         mainCanvas = this;
 
-    scaledSize = glm::vec2
+    referenceResolution = glm::vec2
     {
         GfxEngine::instance->getMainWidth(),
         GfxEngine::instance->getMainHeight(),
@@ -47,15 +47,12 @@ void brl::GfxCanvas::draw()
 
     GfxShaderValue projValue{};
     GfxShaderValue timeValue{};
-    float scale = 2.0f;
 
-    float aspect = scaledSize.x / scaledSize.y;
-    float mainAspect = GfxEngine::instance->getAspectRatio();
+    glm::vec2 screenSize = {GfxEngine::instance->getMainWidth(), GfxEngine::instance->getMainHeight()};
+    // Apply to your UI projection matrix
+    glm::vec2 virtualSize = GetScaledCanvasSize(screenSize);
 
-    scale = aspect / mainAspect;
-
-    projValue.m4value = glm::ortho(0.0f, static_cast<float>(GfxEngine::instance->getMainWidth()) / scale, 0.0f,
-                                   static_cast<float>(GfxEngine::instance->getMainHeight()) / scale, -1.0f, 1.0f);
+    projValue.m4value = glm::ortho(0.0f, virtualSize.x, virtualSize.y, 0.0f, -1.0f, 1.0f);
 
     timeValue.floatValue = glfwGetTime();
 
@@ -74,19 +71,75 @@ void brl::GfxCanvas::draw()
     }
 }
 
-brl::GfxUIElement::GfxUIElement()
+brl::GfxUIElement::GfxUIElement(GfxCanvas* c)
+{
+    canvas = c;
+}
+
+brl::GfxUIRect brl::GfxUIElement::GetRect() const
+{
+    auto parentSize = canvas->referenceResolution;
+
+    if (parent->getEntity<GfxUIElement>())
+        parentSize = parent->getEntity<GfxUIElement>()->GetRect().size;
+
+    // Calculate anchor positions in pixels
+    glm::vec2 anchorMinPixels = anchorMin * parentSize;
+    glm::vec2 anchorMaxPixels = anchorMax * parentSize;
+
+    // Calculate corners
+    glm::vec2 rectMin = anchorMinPixels + offsetMin;
+    glm::vec2 rectMax = anchorMaxPixels + offsetMax;
+
+    // Size and position
+    glm::vec2 size = rectMax - rectMin;
+    glm::vec2 position = rectMin;
+
+    return {position, size};
+}
+
+glm::mat4 brl::GfxUIElement::calculateTransform()
 {
+    glm::vec2 screenSize = {GfxEngine::instance->getMainWidth(), GfxEngine::instance->getMainHeight()};
+
+    // Get scaled canvas size
+    glm::vec2 canvasSize = canvas->GetScaledCanvasSize(screenSize);
+
+    // Set root parent size to canvas size
+    if (!parent)
+    {
+        // This is a root element, use canvas size as parent
+    }
+
+    // Get final position and size
+    glm::vec2 position = GetWorldPosition();
+    glm::vec2 size = GetSize();
+
+    // Apply scale factor
+    float scaleFactor = canvas->GetScaleFactor(screenSize);
+    position *= scaleFactor;
+    size *= scaleFactor;
+
+    // Build transform matrix
+    auto transform = glm::mat4(1.0f);
+    transform = glm::translate(transform, glm::vec3(position, 0));
+    transform = glm::scale(transform, glm::vec3(size, 1));
+
+    return transform;
 }
 
-void brl::GfxUIElement::start()
+
+brl::GfxImage::GfxImage(GfxCanvas* c) :
+    GfxUIElement(c)
 {
-    EcsEntity::start();
-    canvas = getEntityInParent<GfxCanvas>();
 }
 
 void brl::GfxImage::lateUpdate()
 {
     GfxUIElement::lateUpdate();
 
+    material->setTexture("_mainTexture", texture);
+    material->setVec3("_mainColor", color);
+
     canvas->insertDrawCall({calculateTransform(), GfxMesh::GetPrimitive(QUAD)->GetSubMesh(0)->buffer, material});
 }