New scene system, so simple so clean

src/dawn/game/Game.cpp

@@ -4,15 +4,18 @@
 // https://opensource.org/licenses/MIT
 
 #include "Game.hpp"
+#include "scene/Scene.hpp"
+#include "scene/item/SceneItem2D.hpp"
 
 using namespace Dawn;
 
-
 Game::Game() {
+
 }
 
 void Game::init() {
-  
+  currentScene = std::make_shared<Scene>(weak_from_this());
+  auto myItem = currentScene->addSceneItem<SceneItem2D>("myItem");
 }
 
 void Game::update() {
@@ -20,4 +23,5 @@ void Game::update() {
 }
 
 Game::~Game() {
+  
 }

src/dawn/game/Game.hpp

@@ -5,12 +5,13 @@
 
 #pragma once
 #include "dawn.hpp"
-#include "world/Map.hpp"
 
 namespace Dawn {
-  class Game {
+  class Scene;
+
+  class Game : public std::enable_shared_from_this<Game> {
     private:
-      std::shared_ptr<Map> map;
+      std::shared_ptr<Scene> currentScene;
 
     public:
       /**

src/dawn/scene/CMakeLists.txt

@@ -7,4 +7,7 @@
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     Scene.cpp
-)
+)
+
+# Subdirs
+add_subdirectory(item)

src/dawn/scene/Scene.cpp

@@ -7,8 +7,8 @@
 
 using namespace Dawn;
 
-Scene::Scene() {
+Scene::Scene(std::weak_ptr<Game> game) : SceneItem(std::weak_ptr<SceneItem>()) {
-
+  this->game = game;
 }
 
 Scene::~Scene() {

src/dawn/scene/Scene.hpp

@@ -3,20 +3,26 @@
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
-#pragma once
+#pragma ocne
-#include "dawn.hpp"
+#include "scene/item/SceneItem.hpp"
+#include "game/Game.hpp"
 
 namespace Dawn {
-  class Scene {
+  class Scene : public SceneItem {
+    private:
+      std::weak_ptr<Game> game;
+
     public:
       /**
-       * Scene Constructor.
+       * Creates a new Scene.
+       * 
+       * @param game The Game this Scene belongs to.
        */
-      Scene();
+      Scene(std::weak_ptr<Game> game);
 
       /**
-       * Scene Destructor.
+       * Destroys this scene and all of its items.
        */
-      ~Scene();
+      virtual ~Scene();
   };
 }

src/dawn/scene/item/CMakeLists.txt

@@ -0,0 +1,14 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    SceneItem.cpp
+    SceneItem2D.cpp
+)
+
+# Subdirs
+add_subdirectory(display)

src/dawn/scene/item/SceneItem.cpp

@@ -0,0 +1,40 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneItem.hpp"
+
+using namespace Dawn;
+
+SceneItem::SceneItem(
+  std::weak_ptr<SceneItem> parent
+) :
+  parent(parent)
+{
+
+}
+
+std::shared_ptr<SceneItem> SceneItem::getParent() {
+  return parent.lock();
+}
+
+void SceneItem::removeSceneItem(std::shared_ptr<SceneItem> item) {
+  // I don't need to go through the trouble of removing items if I'm already 
+  // disposing, since I'll be clearing them all anyway.
+  if(isDisposing) return;
+
+  auto it = std::find(items.begin(), items.end(), item);
+  if(it != items.end()) items.erase(it);
+}
+
+SceneItem::~SceneItem() {
+  this->isDisposing = true;
+
+  // Clear children first, saves them trying to remove themselves from me.
+  this->items.clear();
+
+  // Now remove myself from my parent.
+  auto parent = this->getParent();
+  if(parent) parent->removeSceneItem(shared_from_this());
+}

src/dawn/scene/item/SceneItem.hpp

@@ -0,0 +1,88 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawn.hpp"
+
+namespace Dawn {
+  class SceneItem : public std::enable_shared_from_this<SceneItem> {
+    private:
+      std::weak_ptr<SceneItem> parent;
+      std::vector<std::shared_ptr<SceneItem>> items;
+      bool_t isDisposing = false;
+
+    public:
+      std::string name;
+
+      /**
+       * Creates a new SceneItem.
+       * 
+       * @param parent The parent SceneItem, or nullptr if root (unlikely).
+       */
+      SceneItem(std::weak_ptr<SceneItem> parent);
+
+      /**
+       * Adds a SceneItem as a child of this SceneItem.
+       * 
+       * @tparam SceneItem type to add.
+       * @return Pointer to the newly created SceneItem.
+       */
+      template<typename C>
+      std::shared_ptr<C> addSceneItem(const std::string &name = "") {
+        auto item = std::make_shared<C>(weak_from_this());
+        auto asItem = std::dynamic_pointer_cast<SceneItem>(item);
+        if(asItem == nullptr) {
+          throw std::runtime_error("SceneItem must be a SceneItem.");
+        }
+        asItem->name = name;
+        items.push_back(asItem);
+        return item;
+      }
+
+      /**
+       * Finds a SceneItem by name.
+       * 
+       * @tparam The type of SceneItem to find.
+       * @param name The name of the SceneItem to find.
+       * @return The SceneItem, or nullptr if not found.
+       */
+      template<typename C>
+      std::shared_ptr<C> find(const std::string &name, const bool_t &recursive = false){
+        for(auto &item : items) {
+          if(item->name == name) {
+            auto casted = std::dynamic_pointer_cast<C>(item);
+            if(!casted) throw std::runtime_error("Invalid SceneItem type.");
+            return casted;
+          }
+
+          if(recursive) {
+            auto childFound = item->find<C>(name, recursive);
+            if(childFound) return childFound;
+          }
+        }
+        
+        return nullptr;
+      }
+
+      /**
+       * Removes a SceneItem from this SceneItem.
+       * 
+       * @param item The SceneItem to remove.
+       */
+      void removeSceneItem(std::shared_ptr<SceneItem> item);
+
+      /**
+       * Gets the parent SceneItem.
+       * 
+       * @return The parent SceneItem.
+       */
+      std::shared_ptr<SceneItem> getParent();
+
+      /**
+       * Destroys this SceneItem.
+       */
+      virtual ~SceneItem();
+  };
+}

src/dawn/scene/item/SceneItem2D.cpp

@@ -0,0 +1,18 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "SceneItem2D.hpp"
+
+using namespace Dawn;
+
+SceneItem2D::SceneItem2D(std::weak_ptr<SceneItem> parent) :
+  SceneItem(parent)
+{
+
+}
+
+SceneItem2D::~SceneItem2D() {
+
+}

src/dawn/scene/item/SceneItem2D.hpp

@@ -0,0 +1,30 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/item/SceneItem.hpp"
+
+namespace Dawn {
+  class SceneItem2D : public SceneItem {
+    private:
+      
+    public:
+      float_t x = 0.0f;
+      float_t y = 0.0f;
+      float_t rotation = 0.0f;
+
+      /**
+       * Creates a new SceneItem2D.
+       * 
+       * @param parent The parent item.
+       */
+      SceneItem2D(std::weak_ptr<SceneItem> parent);
+
+      /**
+       * Destroys this SceneItem2D.
+       */
+      virtual ~SceneItem2D();
+  };
+}

src/dawn/scene/item/display/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    Rectangle.cpp
+)

src/dawn/scene/item/display/Rectangle.cpp

@@ -0,0 +1,18 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Rectangle.hpp"
+
+using namespace Dawn;
+
+Rectangle::Rectangle(std::weak_ptr<SceneItem> parent) :
+  SceneItem2D(parent)
+{
+
+}
+
+Rectangle::~Rectangle() {
+
+}

src/dawn/scene/item/display/Rectangle.hpp

@@ -0,0 +1,27 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/Color.hpp"
+#include "scene/item/SceneItem2D.hpp"
+
+namespace Dawn {
+  class Rectangle : public SceneItem2D {
+    public:
+      struct Color color = COLOR_WHITE;
+
+      /**
+       * Creates a new Rectangle.
+       * 
+       * @param parent The parent SceneItem, or nullptr if root (unlikely).
+       */
+      Rectangle(std::weak_ptr<SceneItem> parent);
+
+      /**
+       * Destroys the Rectangle.
+       */
+      virtual ~Rectangle();
+  };
+}

src/dawn/world/Map.hpp

@@ -1,22 +0,0 @@
-// Copyright (c) 2024 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "dawn.hpp"
-
-namespace Dawn {
-  class Map {
-    public:
-      /**
-       * Creates Map object.
-       */
-      Map();
-
-      /**
-       * Destroys Map object.
-       */
-      ~Map();
-  };
-}