Converted a couple more things to shared pointers.

src/dawn/display/IRenderManager.hpp

@@ -5,32 +5,29 @@
 
 #pragma once
 #include "util/flag.hpp"
-#include "RenderTarget.hpp"
 
 #define RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST FLAG_DEFINE(0)
 #define RENDER_MANAGER_RENDER_FLAG_BLEND FLAG_DEFINE(1)
-typedef flag_t renderflag_t;
 
 namespace Dawn {
   class DawnGame;
   class RenderPipeline;
   class ShaderManager;
+  class RenderTarget;
 
   class IRenderManager {
     protected:
-      renderflag_t renderFlags = 0;
+      flag_t renderFlags = 0;
 
     public:
-      DawnGame *game;
+      std::weak_ptr<DawnGame> game;
 
       /**
        * Default constructor for a render manager instance.
        * 
        * @param game Game that this render manager belongs to.
        */
-      IRenderManager(DawnGame *game) {
-        assertNotNull(game, "IRenderManager::IRenderManager: Game cannot be null");
-        this->game = game;
+      IRenderManager() {
       }
 
       /**
@@ -39,7 +36,7 @@ namespace Dawn {
        * 
        * @return Shared pointer to the backbuffer render target.
        */
-      virtual RenderTarget * getBackBuffer() = 0;
+      virtual std::shared_ptr<RenderTarget> getBackBuffer() = 0;
 
       /**
        * Returns the current render pipeline intended to be used for rendering
@@ -61,14 +58,14 @@ namespace Dawn {
        * 
        * @param renderFlags Render flags to use.
        */
-      virtual void setRenderFlags(renderflag_t renderFlags) = 0;
+      virtual void setRenderFlags(flag_t renderFlags) = 0;
 
       /**
        * Initialize / Start the Render Manager.
        * 
        * @param game Game instance this render manager belongs to.
        */
-      virtual void init() = 0;
+      virtual void init(std::weak_ptr<DawnGame> game) = 0;
 
       /**
        * Perform a synchronous frame update on the render manager.

src/dawn/display/RenderPipeline.cpp

@@ -23,8 +23,11 @@ void RenderPipeline::init() {
 }
 
 void RenderPipeline::render() {
-  if(this->renderManager->game->scene != nullptr) {
-    this->renderScene(this->renderManager->game->scene);
+  auto game = this->renderManager->game.lock();
+  assertNotNull(game, "RenderPipeline::render: Game cannot be null");
+  
+  if(game->scene != nullptr) {
+    this->renderScene(game->scene);
   }
 }
 
@@ -58,7 +61,7 @@ void RenderPipeline::renderScene(Scene *scene) {
   // First, render all non-backbuffer cameras.
   auto it = cameras.begin();
   while(it != cameras.end()) {
-    RenderTarget *cameraTarget = (*it)->getRenderTarget();
+    auto cameraTarget = (*it)->getRenderTarget();
 
     // Leave the backbuffer camera(s) to last, so we skip them. we do this so
     // that children framebuffers contain the CURRENT frame, not LAST frame.

src/dawn/display/shader/ShaderPass.hpp

@@ -19,7 +19,7 @@ namespace Dawn {
     int32_t start = 0;
     int32_t count = -1;
     float_t w = 0;
-    renderflag_t renderFlags = RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST;
+    flag_t renderFlags = RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST;
     enum MeshDrawMode drawMode = MESH_DRAW_MODE_TRIANGLES;
     
     // Parameters