added tree root

Author: NOOBDY

CMakeLists.txt

@@ -42,6 +42,7 @@ set(SRC_FILES
     ${SRC_DIR}/Util/Text.cpp
     ${SRC_DIR}/Util/TransformUtils.cpp
     ${SRC_DIR}/Util/GameObject.cpp
+    ${SRC_DIR}/Util/Root.cpp
 
     ${SRC_DIR}/App.cpp
     ${SRC_DIR}/Giraffe.cpp
@@ -71,7 +72,8 @@ set(INCLUDE_FILES
     ${INCLUDE_DIR}/Util/Text.hpp
     ${INCLUDE_DIR}/Util/Transform.hpp
     ${INCLUDE_DIR}/Util/TransformUtils.hpp
-    ${INCLUDE_DIR}Util/GameObject.hpp
+    ${INCLUDE_DIR}/Util/GameObject.hpp
+    ${INCLUDE_DIR}/Util/Root.hpp
 
     ${INCLUDE_DIR}/App.hpp
     ${INCLUDE_DIR}/Giraffe.hpp

include/Util/GameObject.hpp

@@ -13,11 +13,13 @@ class GameObject {
     GameObject() = default;
 
     GameObject(std::unique_ptr<Core::Drawable> drawable, const float zIndex,
+               const bool visible = true,
                const std::vector<std::shared_ptr<GameObject>> &children =
                    std::vector<std::shared_ptr<GameObject>>())
         : m_Drawable(std::move(drawable)),
           m_Children(children),
-          m_ZIndex(zIndex) {}
+          m_ZIndex(zIndex),
+          m_Visible(visible) {}
 
     GameObject(const GameObject &other) = delete;
 
@@ -28,17 +30,18 @@ class GameObject {
     virtual ~GameObject() = default;
 
     float GetZIndex() const { return m_ZIndex; }
-
-    std::vector<std::shared_ptr<GameObject>> &GetChildren() {
+    Transform GetTransform() const { return m_Transform; }
+    const std::vector<std::shared_ptr<GameObject>> &GetChildren() const {
         return m_Children;
     }
 
     void SetZIndex(float index) { m_ZIndex = index; }
-
     void SetDrawable(std::unique_ptr<Core::Drawable> drawable) {
         m_Drawable = std::move(drawable);
     }
 
+    void SetVisible(bool visible) { m_Visible = visible; }
+
     void AppendChild(std::shared_ptr<GameObject> child) {
         m_Children.push_back(std::move(child));
     }
@@ -57,6 +60,7 @@ class GameObject {
     std::vector<std::shared_ptr<GameObject>> m_Children;
 
     float m_ZIndex;
+    bool m_Visible = true;
 };
 } // namespace Util
 #endif

include/Util/Root.hpp

@@ -0,0 +1,26 @@
+#ifndef UTIL_ROOT_HPP
+#define UTIL_ROOT_HPP
+
+#include <memory>
+#include <vector>
+
+#include "Util/GameObject.hpp"
+
+class App;
+
+namespace Util {
+class Root final {
+public:
+    Root(const std::vector<std::shared_ptr<GameObject>> &children = {});
+
+    void AddChild(std::shared_ptr<GameObject> child);
+    void AddChildren(const std::vector<std::shared_ptr<GameObject>> &children);
+
+    void Update();
+
+private:
+    std::vector<std::shared_ptr<GameObject>> m_Children;
+};
+} // namespace Util
+
+#endif

src/Util/GameObject.cpp

@@ -3,6 +3,10 @@
 namespace Util {
 
 void GameObject::Draw() {
+    if (!m_Visible) {
+        return;
+    }
+
     m_Drawable->Draw(m_Transform, m_ZIndex);
 }
 

src/Util/Root.cpp

@@ -0,0 +1,45 @@
+#include "Util/Root.hpp"
+
+#include "Util/Logger.hpp"
+
+namespace Util {
+Root::Root(const std::vector<std::shared_ptr<GameObject>> &children)
+    : m_Children(children) {}
+
+void Root::AddChild(std::shared_ptr<GameObject> child) {
+    m_Children.push_back(child);
+}
+
+void Root::AddChildren(
+    const std::vector<std::shared_ptr<GameObject>> &children) {
+    m_Children.reserve(m_Children.size() + children.size());
+    m_Children.insert(m_Children.end(), children.begin(), children.end());
+}
+
+void Root::Update() {
+    struct StackInfo {
+        std::shared_ptr<GameObject> m_GameObject;
+        Transform m_ParentTransform;
+    };
+
+    std::vector<StackInfo> stack;
+    stack.reserve(m_Children.size());
+
+    for (const auto &child : m_Children) {
+        stack.push_back(StackInfo{child, Transform{}});
+    }
+
+    while (!stack.empty()) {
+        auto curr = stack.back();
+        stack.pop_back();
+
+        curr.m_GameObject->Update(curr.m_ParentTransform);
+        curr.m_GameObject->Draw();
+
+        for (const auto &child : curr.m_GameObject->GetChildren()) {
+            stack.push_back(
+                StackInfo{child, curr.m_GameObject->GetTransform()});
+        }
+    }
+}
+} // namespace Util