Basic renderhierarchy async updates

src/Engine/UI/CMakeLists.txt

@@ -6,6 +6,8 @@ target_sources(SeeleEngine
         Layout.cpp
         RenderHierarchy.h
         RenderHierarchy.cpp
+        System.h
+        System.cpp
         VerticalLayout.h
         VerticalLayout.cpp)
 

src/Engine/UI/Elements/Element.h

@@ -7,6 +7,7 @@ namespace UI
 {
 //Element defines any part of the UI
 DECLARE_REF(Element)
+DECLARE_REF(System)
 class Element
 {
 public:
@@ -32,6 +33,7 @@ protected:
     bool dirty;
     
     bool enabled;
+    PSystem system;
     PElement parent;
     Array<PElement> children;
     friend class Layout;

src/Engine/UI/RenderHierarchy.cpp

@@ -3,12 +3,18 @@
 using namespace Seele;
 using namespace Seele::UI;
 
-RenderElement::RenderElement() 
+void AddElementRenderHierarchyUpdate::apply(Array<RenderElement>& elements) 
 {
-    
+    for(auto element : elements)
+    {
+        if(element.parent == parent)
+        {
+            
+        }
+    }
 }
 
-RenderElement::~RenderElement() 
+void RemoveElementRenderHierarchyUpdate::apply(Array<RenderElement>& elements) 
 {
     
 }
@@ -23,10 +29,45 @@ RenderHierarchy::~RenderHierarchy()
     
 }
 
-void RenderHierarchy::updateHierarchyIndices() 
+void RenderHierarchy::addElement(PElement addedElement) 
 {
-    for (uint32 i = 0; i < drawElements.size(); i++)
+    std::lock_guard lock(updateLock);
+    updates.add(new AddElementRenderHierarchyUpdate{
+        addedElement.getHandle(), 
+        addedElement->getParent().getHandle()
+    }));
+}
+
+void RenderHierarchy::removeElement(PElement elementToRemove) 
+{
+    std::lock_guard lock(updateLock);
+    updates.add(new RemoveElementRenderHierarchyUpdate{
+        elementToRemove.getHandle(),
+    });
+}
+
+void RenderHierarchy::moveElement(PElement elementToMove, PElement newParent) 
+{
+    std::lock_guard lock(updateLock);
+    updates.add(new AddElementRenderHierarchyUpdate{
+        elementToMove.getHandle(),
+        newParent.getHandle()
+    });
+    updates.add(new RemoveElementRenderHierarchyUpdate{
+        elementToMove.getHandle()
+    });
+}
+
+void RenderHierarchy::updateHierarchy() 
+{
+    Array<RenderHierarchyUpdate*> localUpdates;
+    { // make a local copy of the updates so we dont hold the lock for too long
+        std::lock_guard lock(updateLock);
+        localUpdates = updates;
+        updates.clear();
+    }
+    for(auto update : localUpdates)
     {
-        drawElements[i].hierarchyIndex = i;
+        
     }
 }

src/Engine/UI/RenderHierarchy.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "Elements/Element.h"
+#include "Containers/List.h"
 
 namespace Seele
 {
@@ -9,32 +10,50 @@ DECLARE_NAME_REF(Gfx, RenderCommand);
 class RenderElement
 {
 public:
-    RenderElement();
-    virtual ~RenderElement();
-private:
+    RenderElement() = default;
+    ~RenderElement() = default;
     uint32 hierarchyIndex;
-    RenderElement* parent;
-    PElement referencedElement;
-    Gfx::PRenderCommand renderCommand;
-    friend class RenderHierarchy;
+    Element* parent;
+    Element* referencedElement;
 };
 
 struct RenderHierarchyUpdate
-{};
-DEFINE_REF(RenderHierarchyUpdate)
+{
+    virtual void apply(Array<RenderElement>& elements) = 0;
+};
 
+struct AddElementRenderHierarchyUpdate : public RenderHierarchyUpdate
+{
+    Element* addedElement;
+    Element* parent;
+    virtual void apply(Array<RenderElement>& elements) override;
+};
+
+struct RemoveElementRenderHierarchyUpdate : public RenderHierarchyUpdate
+{
+    Element* element;
+    virtual void apply(Array<RenderElement>& elements) override;
+};
 
 class RenderHierarchy
 {
 public:
     RenderHierarchy();
     ~RenderHierarchy();
-    
-private:
-    void updateHierarchyIndices();
+    // logic thread interface, queue hierarchy changes
+    void addElement(PElement addedElement);
+    void removeElement(PElement elementToRemove);
+    void moveElement(PElement elementToMove, PElement newParent);
 
+    // render thread interface, apply changes
+    void updateHierarchy();
+private:
+    static_assert(std::is_trivially_copyable_v<RenderElement>);
     // List of all drawable elements in draw order
     Array<RenderElement> drawElements;
+
+    List<RenderHierarchyUpdate*> updates;
+    std::mutex updateLock;
 };
 } // namespace UI
 } // namespace Seele

src/Engine/UI/System.cpp

@@ -0,0 +1,14 @@
+#include "System.h"
+
+using namespace Seele;
+using namespace Seele::UI;
+
+System::System() 
+{
+    
+}
+
+System::~System() 
+{
+    
+}

src/Engine/UI/System.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "MinimalEngine.h"
+#include "RenderHierarchy.h"
+
+namespace Seele
+{
+namespace UI
+{
+DECLARE_REF(Panel)
+class System
+{
+public:
+    System();
+    virtual ~System();
+private:
+    PPanel rootPanel;
+    Array<RenderHierarchyUpdate*> updates;
+};
+DEFINE_REF(System)
+} // namespace UI
+} // namespace Seele