Merge pull request #84 from NOOBDY/root

Add auto tree rendering root

Author: Dragonfly911117

CMakeLists.txt

@@ -42,9 +42,9 @@ 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}/Triangle.cpp
     ${SRC_DIR}/Giraffe.cpp
 )
 set(INCLUDE_DIR ${CMAKE_SOURCE_DIR}/include)
@@ -72,10 +72,10 @@ 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}/Triangle.hpp
     ${INCLUDE_DIR}/Giraffe.hpp
     ${INCLUDE_DIR}/config.hpp
 )

include/App.hpp

@@ -4,7 +4,6 @@
 #include "pch.hpp" // IWYU pragma: export
 
 #include "Giraffe.hpp"
-#include "Triangle.hpp"
 
 class App {
 public:
@@ -23,8 +22,7 @@ class App {
 private:
     State m_CurrentState = State::START;
 
-    Triangle m_Triangle;
-    std::shared_ptr<Giraffe> m_Giraffe= std::make_shared<Giraffe>();
+    std::shared_ptr<Giraffe> m_Giraffe = std::make_shared<Giraffe>();
 };
 
 #endif

include/Triangle.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,18 +30,19 @@ 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 AppendChild(std::shared_ptr<GameObject> child) {
+    void SetVisible(bool visible) { m_Visible = visible; }
+
+    void AddChild(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/GameObject.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

include/Util/Root.hpp

@@ -17,7 +17,7 @@ void App::Start() {
                                             "Giraffe");
     gf->SetZIndex(m_Giraffe->GetZIndex() - 1);
     gf->Start();
-    m_Giraffe->AppendChild(gf);
+    m_Giraffe->AddChild(gf);
 
     m_CurrentState = State::UPDATE;
 }

src/App.cpp

@@ -1,20 +1,27 @@
 #include "Giraffe.hpp"
+
+#include <cmath>
+
 #include "Util/GameObject.hpp"
 #include "Util/Image.hpp"
+#include "Util/Logger.hpp"
 #include "Util/Text.hpp"
 #include "Util/Time.hpp"
 #include "Util/Transform.hpp"
+
 #include "config.hpp"
 
 void GiraffeText::Update(const Util::Transform &transform) {
     auto &pos = m_Transform.translation;
     auto &scale = m_Transform.scale;
     auto &rotation = m_Transform.rotation;
 
-    pos += transform.translation;
-    rotation += transform.rotation;
+    pos = transform.translation;
+    // rotation = std::fmod(rotation + 50.0F, 360.0F);
     scale = transform.scale;
 
+    LOG_DEBUG("{} {}", scale.x, scale.y);
+
     m_Drawable->Draw(m_Transform, m_ZIndex);
 }
 
@@ -31,10 +38,12 @@ void Giraffe::Update([[maybe_unused]] const Util::Transform &transform) {
     auto &scale = m_Transform.scale;
     auto &rotation = m_Transform.rotation;
 
-    if (pos.y > WINDOW_HEIGHT || pos.y + WINDOW_HEIGHT < 0) {
+    if (pos.y >= static_cast<float>(WINDOW_HEIGHT) / 2 ||
+        pos.y + static_cast<float>(WINDOW_HEIGHT) / 2 <= 0) {
         dir.y *= -1;
     }
-    if (pos.x > WINDOW_WIDTH || pos.x + WINDOW_WIDTH < 0) {
+    if (pos.x >= static_cast<float>(WINDOW_WIDTH) / 2 ||
+        pos.x + static_cast<float>(WINDOW_WIDTH) / 2 <= 0) {
         dir.x *= -1;
     }
 
@@ -49,7 +58,7 @@ void Giraffe::Update([[maybe_unused]] const Util::Transform &transform) {
 
     m_Drawable->Draw(m_Transform, m_ZIndex);
     for (auto &child : m_Children) {
-        child->Update(deltaTransform);
+        child->Update(m_Transform);
     }
 
     // LOG_DEBUG("GIRA: x: {}, y: {}", pos.x, pos.y);

src/Giraffe.cpp

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

src/Triangle.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