Even more shared pointers.

src/dawn/display/Color.cpp

@@ -8,7 +8,7 @@
 
 using namespace Dawn;
 
-struct Color Color::fromString(std::string str) {
+struct Color Color::fromString(const std::string str) {
   // Convert to lowercase
   auto lower = stringToLowercase(str);
   

src/dawn/display/Color.hpp

@@ -20,7 +20,7 @@ namespace Dawn {
      * @param str String to parse.
      * @return Color parsed.
      */
-    static struct Color fromString(std::string str);
+    static struct Color fromString(const std::string str);
 
     float_t r, g, b, a;
 

src/dawn/display/IRenderManager.hpp

@@ -15,7 +15,7 @@ namespace Dawn {
   class ShaderManager;
   class RenderTarget;
 
-  class IRenderManager {
+  class IRenderManager : public std::enable_shared_from_this<IRenderManager> {
     protected:
       flag_t renderFlags = 0;
 
@@ -44,14 +44,14 @@ namespace Dawn {
        * 
        * @return Reference to the currently active main scene render pipeline.
        */
-      virtual RenderPipeline * getRenderPipeline() = 0;
+      virtual std::shared_ptr<RenderPipeline> getRenderPipeline() = 0;
 
       /**
        * Returns the shader manager that this render manager uses.
        * 
        * @return Reference to the shader manager.
        */
-      virtual ShaderManager * getShaderManager() = 0;
+      virtual std::shared_ptr<ShaderManager> getShaderManager() = 0;
       
       /**
        * Sets the render flags for the render manager to use.

src/dawn/display/RenderPipeline.cpp

@@ -13,32 +13,35 @@
 
 using namespace Dawn;
 
-RenderPipeline::RenderPipeline(RenderManager *renderManager) {
-  assertNotNull(renderManager, "RenderPipeline::RenderPipeline: RenderManager cannot be null");
-  this->renderManager = renderManager;
+RenderPipeline::RenderPipeline() {
 }
 
-void RenderPipeline::init() {
-  this->shaderBuffer.init();
+void RenderPipeline::init(const std::weak_ptr<RenderManager> renderManager) {
+  this->renderManager = renderManager;
+  shaderBuffer.init();
 }
 
 void RenderPipeline::render() {
-  auto game = this->renderManager->game.lock();
+  auto rm = renderManager.lock();
+  assertNotNull(rm, "RenderPipeline::render: RenderManager cannot be null");
+  auto game = rm->game.lock();
   assertNotNull(game, "RenderPipeline::render: Game cannot be null");
   
   if(game->scene != nullptr) {
-    this->renderScene(game->scene);
+    renderScene(game->scene);
   }
 }
 
-void RenderPipeline::renderScene(Scene *scene) {
+void RenderPipeline::renderScene(std::shared_ptr<Scene> scene) {
   assertNotNull(scene, "RenderPipeline::renderScene: Scene cannot be null");
+  auto rm = renderManager.lock();
+  assertNotNull(rm, "RenderPipeline::renderScene: RenderManager cannot be null");
 
   // Render subscenes first.
   auto subSceneControllers = scene->findComponents<SubSceneController>();
   auto itSubScene = subSceneControllers.begin();
   while(itSubScene != subSceneControllers.end()) {
-    Scene *subScene = (Scene *)((*itSubScene)->subScene);
+    auto subScene = (*itSubScene)->subScene;
     if(subScene == nullptr) {
       ++itSubScene;
       continue;
@@ -49,12 +52,12 @@ void RenderPipeline::renderScene(Scene *scene) {
       continue;
     }
 
-    this->renderScene(subScene);
+    renderScene(subScene);
     ++itSubScene;
   }
 
   // Now render backbuffers.
-  auto backBuffer = this->renderManager->getBackBuffer();
+  auto backBuffer = rm->getBackBuffer();
   auto cameras = scene->findComponents<Camera>();
   Camera *backBufferCamera = nullptr;
 
@@ -71,7 +74,7 @@ void RenderPipeline::renderScene(Scene *scene) {
     } else if(cameraTarget == backBuffer) {
       backBufferCamera = *it;
     } else {
-      this->renderSceneCamera(scene, *it);
+      renderSceneCamera(&(*scene), *it);
     }
 
     ++it;
@@ -79,10 +82,13 @@ void RenderPipeline::renderScene(Scene *scene) {
 
   // Now render the backbuffer camera.
   if(backBufferCamera == nullptr) return;
-  this->renderSceneCamera(scene, backBufferCamera);
+  renderSceneCamera(&(*scene), backBufferCamera);
 }
 
 void RenderPipeline::renderSceneCamera(Scene *scene, Camera *camera) {
+  auto rm = renderManager.lock();
+  assertNotNull(rm, "RenderPipeline::renderSceneCamera: RenderManager cannot be null");
+
   std::vector<struct ShaderPassItem>::iterator itPassItem;
 
   assertNotNull(scene, "RenderPipeline::renderSceneCamera: Scene cannot be null");
@@ -90,7 +96,7 @@ void RenderPipeline::renderSceneCamera(Scene *scene, Camera *camera) {
 
   // Create a new render ID. Long story short this is a really dirty way of 
   // not sending parameters to shaders more than we need.
-  this->renderId--;
+  renderId--;
 
   // Get the render target.
   auto renderTarget = camera->getRenderTarget();
@@ -100,7 +106,7 @@ void RenderPipeline::renderSceneCamera(Scene *scene, Camera *camera) {
   struct RenderPipelineShaderBufferData shaderBufferData;
   shaderBufferData.projection = camera->getProjection();
   shaderBufferData.view = camera->transform->getWorldTransform();
-  this->shaderBuffer.buffer(&shaderBufferData);
+  shaderBuffer.buffer(&shaderBufferData);
 
   // Prepare a render context. This is just a nice way of letting renderables 
   // know a bit about what is happening, they can choose to use this data to
@@ -137,7 +143,7 @@ void RenderPipeline::renderSceneCamera(Scene *scene, Camera *camera) {
           &lineMesh,
           &lineIndex,
           camera,
-          this->renderManager->simpleTexturedShader
+          renderManager->simpleTexturedShader
         );
         shaderPassItems.push_back(item);
         itDebugLine = scene->debugLines.erase(itDebugLine);
@@ -260,7 +266,7 @@ void RenderPipeline::renderSceneCamera(Scene *scene, Camera *camera) {
     }
 
     // Set Render flags
-    this->renderManager->setRenderFlags(item.renderFlags);
+    rm->setRenderFlags(item.renderFlags);
 
     // Thank god that's done, now just draw the damn mesh.
     item.mesh->draw(item.drawMode, item.start, item.count);

src/dawn/display/RenderPipeline.hpp

@@ -18,22 +18,22 @@ namespace Dawn {
       int_fast16_t renderId = -1;
 
     public:
-      RenderManager *renderManager;
+      std::weak_ptr<RenderManager> renderManager;
       RenderPipelineShaderBuffer shaderBuffer;
 
       /**
        * Constructs a new RenderPipeline. Render Pipelines are my attempt to
        * create both a flexible, but standard way to allow the individual games
        * to decide how they want to render the common scene-item models.
-       * 
-       * @param renderManager Parent render manager this pipeline belongs to.
        */
-      RenderPipeline(RenderManager *renderManager);
+      RenderPipeline();
 
       /**
        * Initialize the render pipeline.
+       * 
+       * @param renderManager Parent render manager this pipeline belongs to.
        */
-      virtual void init();
+      virtual void init(const std::weak_ptr<RenderManager> renderManager);
       
       /**
        * Renders the games' currently active scene, and all of its' cameras.
@@ -46,7 +46,7 @@ namespace Dawn {
        * 
        * @param scene Scene to render.
        */
-      virtual void renderScene(Scene *scene);
+      virtual void renderScene(std::shared_ptr<Scene> scene);
 
       /**
        * Render a specific camera on a specific scene.