Fixed all my pointers

src/dawn/scene/Scene.cpp

@@ -8,8 +8,7 @@
 
 using namespace Dawn;
 
-Scene::Scene(std::weak_ptr<DawnGame> game) {
-  this->game = game;
+Scene::Scene(DawnGame &game) : game(game) {
   this->nextId = 0;
 }
 
@@ -30,7 +29,7 @@ void Scene::update() {
 
 std::shared_ptr<SceneItem> Scene::createSceneItem() {
   sceneitemid_t id = this->nextId++;
-  auto item = std::make_shared<SceneItem>(weak_from_this(), id);
+  auto item = std::make_shared<SceneItem>(*this, id);
   this->itemsNotInitialized[id] = item;
   return item;
 }

src/dawn/scene/Scene.hpp

@@ -9,23 +9,21 @@
 namespace Dawn {
   class DawnGame;
 
-  class Scene :
-    public std::enable_shared_from_this<Scene>
-  {
+  class Scene {
     private:
       sceneitemid_t nextId;
-      std::map<sceneitemid_t,std::shared_ptr<SceneItem>> items;
-      std::map<sceneitemid_t,std::shared_ptr<SceneItem>> itemsNotInitialized;
+      std::map<sceneitemid_t, std::shared_ptr<SceneItem>> items;
+      std::map<sceneitemid_t, std::shared_ptr<SceneItem>> itemsNotInitialized;
 
     public:
-      std::weak_ptr<DawnGame> game;
+      DawnGame &game;
 
       /**
        * Construct a new Scene instance.
        * 
-       * @param game Weak pointer to the game that this scene belongs to.
+       * @param game Reference to the game that this scene belongs to.
        */
-      Scene(std::weak_ptr<DawnGame> game);
+      Scene(DawnGame &game);
 
       /**
        * Perform a one frame synchronous tick on the current scene. This may
@@ -59,6 +57,25 @@ namespace Dawn {
         return nullptr;
       }
 
+      /**
+       * Finds all exisitng components on the scene (Root Level Only) that has a
+       * matching component of the given component type.
+       * 
+       * @tparam Component type to look for.
+       * @return List of matching compnoents.
+       */
+      template<class T>
+      std::vector<std::shared_ptr<T>> findComponents() {
+        std::vector<std::shared_ptr<T>> components;
+        auto it = this->items.begin();
+        while(it != this->items.end()) {
+          auto component = it->second->getComponent<T>();
+          if(component != nullptr) components.push_back(component);
+          ++it;
+        }
+        return components;
+      }
+
       /**
        * Destroys a previously initialized Scene.
        */

src/dawn/scene/SceneItem.cpp

@@ -8,8 +8,10 @@
 
 using namespace Dawn;
 
-SceneItem::SceneItem(std::weak_ptr<Scene>, sceneitemid_t id) {
-  this->scene = scene;
+SceneItem::SceneItem(Scene &scene, sceneitemid_t id) :
+  scene(scene),
+  id(id)
+{
   this->id = id;
 }
 

src/dawn/scene/SceneItem.hpp

@@ -11,14 +11,12 @@ namespace Dawn {
 
   class Scene;
 
-  class SceneItem :
-    public std::enable_shared_from_this<SceneItem>
-  {
+  class SceneItem {
     private:
       std::vector<std::shared_ptr<SceneItemComponent>> components;
 
     public:
-      std::weak_ptr<Scene> scene;
+      Scene &scene;
       sceneitemid_t id;
 
       /**
@@ -28,7 +26,7 @@ namespace Dawn {
        * @param scene Weak pointer to the Scene that this SceneItem belongs to.
        * @param id Scene Item ID that the Scene assigned this SceneItem.
        */
-      SceneItem(std::weak_ptr<Scene> scene, sceneitemid_t id);
+      SceneItem(Scene &scene, sceneitemid_t id);
       
       /**
        * Called by the Scene the frame after we were constructed so we can begin
@@ -48,7 +46,7 @@ namespace Dawn {
        */
       template<class T>
       std::shared_ptr<T> addComponent() {
-        auto component = std::make_shared<T>(weak_from_this());
+        auto component = std::make_shared<T>(*this);
         this->components.push_back(component);
         return component;
       }

src/dawn/scene/SceneItemComponent.cpp

@@ -10,16 +10,15 @@
 
 using namespace Dawn;
 
-SceneItemComponent::SceneItemComponent(std::weak_ptr<SceneItem> item) {
-  this->item = item;
+SceneItemComponent::SceneItemComponent(SceneItem &item) : item(item) {
 }
 
-std::shared_ptr<Scene> SceneItemComponent::getScene() {
-  return this->item.lock()->scene.lock();
+Scene & SceneItemComponent::getScene() {
+  return this->item.scene;
 }
 
-std::shared_ptr<DawnGame> SceneItemComponent::getGame() {
-  return this->item.lock()->scene.lock()->game.lock();
+DawnGame & SceneItemComponent::getGame() {
+  return this->item.scene.game;
 }
 
 SceneItemComponent::~SceneItemComponent() {

src/dawn/scene/SceneItemComponent.hpp

@@ -13,14 +13,14 @@ namespace Dawn {
 
   class SceneItemComponent {
     public:
-      std::weak_ptr<SceneItem> item;
+      SceneItem &item;
 
-      SceneItemComponent(std::weak_ptr<SceneItem> item);
+      SceneItemComponent(SceneItem &item);
       
       virtual void start() = 0;
 
-      std::shared_ptr<Scene> getScene();
-      std::shared_ptr<DawnGame> getGame();
+      Scene & getScene();
+      DawnGame & getGame();
 
       virtual ~SceneItemComponent();
   };

src/dawn/scene/components/DummyComponent.hpp

@@ -9,7 +9,9 @@
 namespace Dawn {
   class DummyComponent : public SceneItemComponent {
     public:
-      DummyComponent(std::weak_ptr<SceneItem> item) : SceneItemComponent(item) {
+      DummyComponent(SceneItem &item) :
+        SceneItemComponent(item)
+      {
         std::cout << "Dummy Component Initialized" << std::endl;
       };
 

src/dawn/scene/components/display/Camera.cpp

@@ -9,7 +9,9 @@
 
 using namespace Dawn;
 
-Camera::Camera(std::weak_ptr<SceneItem> item) : SceneItemComponent(item) {
+Camera::Camera(SceneItem &item) :
+  SceneItemComponent(item)
+{
 }
 
 void Camera::updateProjection() {
@@ -36,17 +38,16 @@ void Camera::updateProjection() {
   }
 }
 
-std::shared_ptr<RenderTarget> Camera::getRenderTarget() {
+RenderTarget & Camera::getRenderTarget() {
   if(this->target == nullptr) {
-    return this->getGame()->renderManager.getBackBuffer();
+    return this->getGame().renderManager.getBackBuffer();
   }
-
-  return this->target;
+  return *this->target;
 }
 
 float_t Camera::getAspect() {
-  auto target = this->getRenderTarget();
-  return target->getWidth() / target->getHeight();
+  RenderTarget &target = this->getRenderTarget();
+  return target.getWidth() / target.getHeight();
 }
 
 void Camera::start() {

src/dawn/scene/components/display/Camera.hpp

@@ -37,14 +37,14 @@ namespace Dawn {
        * 
        * @param item SceneItem that this component belongs to.
        */
-      Camera(std::weak_ptr<SceneItem> item);
+      Camera(SceneItem &item);
 
       /**
        * Updates the projection matrix.
        */
       void updateProjection();
 
-      std::shared_ptr<RenderTarget> getRenderTarget();
+      RenderTarget & getRenderTarget();
 
       /**
        * Returs the aspect ratio of the camera.

src/dawn/scene/components/display/MeshRenderer.cpp

@@ -7,7 +7,7 @@
 
 using namespace Dawn;
 
-MeshRenderer::MeshRenderer(std::weak_ptr<SceneItem> item) :
+MeshRenderer::MeshRenderer(SceneItem &item) :
   SceneItemComponent(item)
 {
   

src/dawn/scene/components/display/MeshRenderer.hpp

@@ -12,7 +12,7 @@ namespace Dawn {
     public:
       std::shared_ptr<Mesh> mesh = nullptr;
 
-      MeshRenderer(std::weak_ptr<SceneItem> item);
+      MeshRenderer(SceneItem &item);
 
       void start() override;
   };