Pursche/indirect UI renderer (#65)

* Make CanvasRenderer use IndirectDraw

Merge Panel and Text into single renderpipeline
Add CPU sorting of CanvasRenderer drawcalls
Move CanvasRenderer to indirect drawcalls
Considered using GPU sorting but CPU was faster
Add sorting test to UI/Demo.luau

Fix key mapping mixup in Input.luau
Fix hardcoded Light color
Add GPU RadixSort utils, currently unused
Get rid of old GPU FFX ParallelSort

* Update Engine submodule

Author: Pursche

.gitignore

@@ -39,4 +39,6 @@ CMakeSettings.json
 
 # Exceptions
 .cache/
-*.patch
+*.patch
+.claude/
+images/

Source/Game-Lib/Game-Lib/ECS/Components/UI/Widget.h

@@ -39,6 +39,10 @@ namespace ECS::Components::UI
         WidgetFlags flags = WidgetFlags::Default;
         u32 worldTransformIndex = std::numeric_limits<u32>().max();
 
+        // Packed draw-order sortkey computed by CanvasRenderer. See CanvasRenderer::DfsAssignSortKey for the layout.
+        // Sibling-order tiebreaker lives on SceneNode2D as siblingIndex (monotonic per-parent).
+        u32 sortKey = 0;
+
         Scripting::UI::Widget* scriptWidget = nullptr;
 
         // Non mutable helper functions
@@ -55,4 +59,12 @@ namespace ECS::Components::UI
     struct DirtyWidgetClipper {};
     struct DirtyWidgetWorldTransformIndex {};
     struct DestroyWidget {};
+
+    // Marks a canvas whose widget subtree needs its sortKeys recomputed by CanvasRenderer.
+    struct DirtyCanvasSort {};
+
+    // Registry-context singleton: set when the SET of canvases (or a canvas's layer) changes,
+    // so CanvasRenderer knows it needs to re-rank canvasOrder before re-running DfsAssignSortKey.
+    // Cleared inside CanvasRenderer::Update after RebuildCanvasOrder runs.
+    struct DirtyCanvasOrderFlag {};
 }

Source/Game-Lib/Game-Lib/ECS/Util/Transform2D.h

@@ -287,8 +287,10 @@ namespace ECS::Components
                     prevSibling->nextSibling = nextSibling;
                     nextSibling->prevSibling = prevSibling;
 
+                    // If we were the head of the list, the new head is the next sibling
+                    // (which preserves insertion order: the second-inserted child becomes first).
                     if (parent->firstChild == this)
-                        parent->firstChild = prevSibling;
+                        parent->firstChild = nextSibling;
                 }
 
                 nextSibling = nullptr;
@@ -312,14 +314,20 @@ namespace ECS::Components
             }
             else
             {
-                //insert after the firstchild
-                nextSibling = newParent->firstChild->nextSibling;
-                prevSibling = newParent->firstChild;
+                // Append to the END of the circular sibling list (i.e. insert just before firstChild).
+                // This makes iteration order match insertion order, so siblings are drawn in the order they were created.
+                nextSibling = newParent->firstChild;
+                prevSibling = newParent->firstChild->prevSibling;
 
                 prevSibling->nextSibling = this;
                 nextSibling->prevSibling = this;
             }
             parent = newParent;
+
+            // Assign a unique-within-current-siblings index. Using a monotonic counter on
+            // the parent rather than parent->children guarantees uniqueness even after
+            // detach+reattach cycles (where children decrements but nextSiblingIndex does not).
+            siblingIndex = newParent->nextSiblingIndex++;
         }
 
         //updates transform matrix of the children. does not recalculate matrix
@@ -385,6 +393,21 @@ namespace ECS::Components
         SceneNode2D* nextSibling{};
         SceneNode2D* prevSibling{};
         i32 children{ 0 };
+
+        // Monotonic per-parent counter. Bumped each time a child is attached; used
+        // to assign a unique siblingIndex that never collides with concurrent siblings,
+        // even after detach/reattach cycles on the same parent. u32 so wraparound is
+        // irrelevant at any realistic UI churn rate.
+        u32 nextSiblingIndex{ 0 };
+        // Unique index within this node's current parent. Set by SetParent. Used as
+        // the tiebreaker when two siblings have the same Z in the draw sort.
+        u32 siblingIndex{ 0 };
+
+    public:
+        u32 GetSiblingIndex() const 
+        { 
+            return siblingIndex; 
+        }
     };
 }
 

Source/Game-Lib/Game-Lib/ECS/Util/UIUtil.cpp

@@ -34,6 +34,42 @@ namespace ECS::Util
 {
     namespace UI
     {
+        entt::entity FindOwningCanvas(entt::registry* registry, entt::entity entity)
+        {
+            if (entity == entt::null) 
+                return entt::null;
+
+            auto* widget = registry->try_get<ECS::Components::UI::Widget>(entity);
+            if (!widget) 
+                return entt::null;
+
+            if (widget->type == ECS::Components::UI::WidgetType::Canvas)
+                return entity;
+
+            if (widget->scriptWidget)
+                return widget->scriptWidget->canvasEntity;
+
+            return entt::null;
+        }
+
+        void MarkCanvasSortDirty(entt::registry* registry, entt::entity canvasEntity)
+        {
+            if (canvasEntity == entt::null) 
+                return;
+            registry->emplace_or_replace<ECS::Components::UI::DirtyCanvasSort>(canvasEntity);
+        }
+
+        void MarkAllCanvasSortDirty(entt::registry* registry)
+        {
+            registry->view<ECS::Components::UI::Canvas>().each([&](entt::entity canvasEntity, auto&)
+            {
+                registry->emplace_or_replace<ECS::Components::UI::DirtyCanvasSort>(canvasEntity);
+            });
+            // The canvas SET changed -> canvasOrder ranking is stale; gates the (relatively
+            // expensive) RebuildCanvasOrder pass next time CanvasRenderer::Update runs.
+            registry->ctx().emplace<ECS::Components::UI::DirtyCanvasOrderFlag>();
+        }
+
         entt::entity GetOrEmplaceCanvas(Scripting::UI::Widget*& widget, entt::registry* registry, const char* name, vec2 pos, ivec2 size, bool isRenderTexture)
         {
             ECS::Singletons::UISingleton& uiSingleton = registry->ctx().get<ECS::Singletons::UISingleton>();
@@ -109,6 +145,11 @@ namespace ECS::Util
                 registry->emplace<ECS::Components::UI::CanvasRenderTargetTag>(entity);
             }
 
+            // A new canvas entering the system shifts canvasOrder for everyone;
+            // mark every canvas (including this one) so all widget sortKeys get their
+            // canvasOrder bits refreshed on the next CanvasRenderer::Update tick.
+            MarkAllCanvasSortDirty(registry);
+
             return entity;
         }
 
@@ -201,6 +242,9 @@ namespace ECS::Util
             eventInputInfo.onFocusEndEvent = panelTemplateComp.onFocusEndEvent;
             eventInputInfo.onFocusHeldEvent = panelTemplateComp.onFocusHeldEvent;
 
+            // New widget entering the tree -> owning canvas needs sort-key rebuild.
+            MarkCanvasSortDirty(registry, FindOwningCanvas(registry, parent));
+
             return entity;
         }
 
@@ -285,6 +329,9 @@ namespace ECS::Util
             eventInputInfo.onFocusEndEvent = textTemplate.onFocusEndEvent;
             eventInputInfo.onFocusHeldEvent = textTemplate.onFocusHeldEvent;
 
+            // New widget entering the tree -> owning canvas needs sort-key rebuild.
+            MarkCanvasSortDirty(registry, FindOwningCanvas(registry, parent));
+
             return entity;
         }
 
@@ -311,6 +358,9 @@ namespace ECS::Util
             widgetComp.type = ECS::Components::UI::WidgetType::Widget;
             widgetComp.scriptWidget = widget;
 
+            // New widget entering the tree -> owning canvas needs sort-key rebuild.
+            MarkCanvasSortDirty(registry, FindOwningCanvas(registry, parent));
+
             return entity;
         }
 
@@ -319,6 +369,10 @@ namespace ECS::Util
             if (!registry->all_of<ECS::Components::UI::Widget>(entity))
                 return false;
 
+            // Widgets leaving the tree changes the sibling set in their owning canvas.
+            // Mark it dirty BEFORE we mutate the scriptWidget or clear the parent, so FindOwningCanvas still resolves.
+            MarkCanvasSortDirty(registry, FindOwningCanvas(registry, entity));
+
             auto& transform2DSystem = Transform2DSystem::Get(*registry);
             transform2DSystem.ClearParent(entity);
 
@@ -382,6 +436,10 @@ namespace ECS::Util
                     CallLuaEvent(eventInputInfo->onFocusBeginEvent, Scripting::UI::UIInputEvent::FocusBegin, widget.scriptWidget);
                 }
             }
+
+            // Focus affects sortKey (priority bits), so both the previously focused and the newly focused widget's canvases need their sortKeys rebuilt.
+            MarkCanvasSortDirty(registry, FindOwningCanvas(registry, oldFocus));
+            MarkCanvasSortDirty(registry, FindOwningCanvas(registry, entity));
         }
 
         entt::entity GetFocusedWidgetEntity(entt::registry* registry)

Source/Game-Lib/Game-Lib/ECS/Util/UIUtil.h

@@ -36,6 +36,18 @@ namespace ECS::Util
         void FocusWidgetEntity(entt::registry* registry, entt::entity entity);
         entt::entity GetFocusedWidgetEntity(entt::registry* registry);
 
+        // Returns the canvas entity that owns the given widget entity (the widget itself if it IS a canvas).
+        // Walks the scriptWidget->canvasEntity chain; returns entt::null if the entity has no Widget component.
+        entt::entity FindOwningCanvas(entt::registry* registry, entt::entity entity);
+
+        // Mark a single canvas as needing its widget sort-keys recomputed (by CanvasRenderer::Update next frame).
+        // Safe to call with entt::null; becomes a no-op.
+        void MarkCanvasSortDirty(entt::registry* registry, entt::entity canvasEntity);
+
+        // Mark every canvas in the registry as needing sort-keys recomputed. Used when the set of canvases itself
+        // changes (new canvas, canvas SetLayer) so that canvasOrder bits are refreshed everywhere.
+        void MarkAllCanvasSortDirty(entt::registry* registry);
+
         void RefreshText(entt::registry* registry, entt::entity entity, std::string_view newText);
         void RefreshTemplate(entt::registry* registry, entt::entity entity, ECS::Components::UI::EventInputInfo& eventInputInfo);
         void RefreshClipper(entt::registry* registry, entt::entity entity);