Fixed all my pointers

src/dawnopengl/display/BackBufferRenderTarget.cpp

@@ -7,10 +7,9 @@
 
 using namespace Dawn;
 
-BackBufferRenderTarget::BackBufferRenderTarget(
-  std::weak_ptr<RenderManager> renderManager
-) {
-  this->renderManager = renderManager;
+BackBufferRenderTarget::BackBufferRenderTarget(RenderManager &renderManager) :
+  renderManager(renderManager)
+{
 }
 
 float_t BackBufferRenderTarget::getWidth() {

src/dawnopengl/display/BackBufferRenderTarget.hpp

@@ -6,18 +6,19 @@
 #pragma once
 #include "dawnopengl.hpp"
 #include "display/RenderTarget.hpp"
-#include "display/RenderManager.hpp"
 
 namespace Dawn {
+  class RenderManager;
+
   class BackBufferRenderTarget : public RenderTarget {
     private:
-      std::weak_ptr<RenderManager> renderManager;
+      RenderManager &renderManager;
       float_t width = 1;
-      float_t height = 1;
+      float_t height = 1; 
       struct Color clearColor = COLOR_CORNFLOWER_BLUE;
 
     public:
-      BackBufferRenderTarget(std::weak_ptr<RenderManager> renderManager);
+      BackBufferRenderTarget(RenderManager &renderManager);
 
       float_t getWidth() override;
       float_t getHeight() override;

src/dawnopengl/display/CMakeLists.txt

@@ -8,6 +8,7 @@ target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     RenderManager.cpp
     BackBufferRenderTarget.cpp
+    StandardRenderPipeline.cpp
 )
 
 # Subdirs

src/dawnopengl/display/RenderManager.cpp

@@ -6,28 +6,31 @@
 #include "dawnopengl.hpp"
 #include "game/DawnGame.hpp"
 #include "display/RenderManager.hpp"
-#include "display/BackBufferRenderTarget.hpp"
+#include "display/StandardRenderPipeline.hpp"
 
 using namespace Dawn;
 
-RenderManager::RenderManager(std::weak_ptr<DawnGame> game) {
-  this->game = game;
-  this->renderTarget=std::make_shared<BackBufferRenderTarget>(weak_from_this());
+RenderManager::RenderManager(DawnGame &game) :
+  IRenderManager(game),
+  backBuffer(*this)
+{
+  this->standardRenderPipeline=std::make_shared<StandardRenderPipeline>(*this);
 }
 
 void RenderManager::init() {
+  this->standardRenderPipeline->init();
 }
 
-std::shared_ptr<RenderTarget> RenderManager::getBackBuffer() {
-  return this->renderTarget;
+RenderTarget & RenderManager::getBackBuffer() {
+  return this->backBuffer;
+}
+
+RenderPipeline & RenderManager::getRenderPipeline() {
+  return *this->standardRenderPipeline;
 }
 
 void RenderManager::update() {
-  this->getBackBuffer()->bind();
-  this->getBackBuffer()->clear(
-    RENDER_TARGET_CLEAR_FLAG_COLOR |
-    RENDER_TARGET_CLEAR_FLAG_DEPTH
-  );
+  this->getRenderPipeline().render();
 }
 
 RenderManager::~RenderManager() {

src/dawnopengl/display/RenderManager.hpp

@@ -5,26 +5,24 @@
 
 #pragma once
 #include "display/_RenderManager.hpp"
+#include "display/BackBufferRenderTarget.hpp"
 
 namespace Dawn {
-  class BackBufferRenderTarget;
+  class StandardRenderPipeline;
 
-  class RenderManager :
-    public IRenderManager,
-    public std::enable_shared_from_this<RenderManager>
-  {
+  class RenderManager : public IRenderManager {
+    private:
+      std::shared_ptr<StandardRenderPipeline> standardRenderPipeline;
 
     public:
-      std::shared_ptr<BackBufferRenderTarget> renderTarget;
-    
+      BackBufferRenderTarget backBuffer;
+
       /**
        * Construct a new RenderManager for a game instance.
-       * 
-       * @param game Game instance this render manager belongs to.
        */
-      RenderManager(std::weak_ptr<DawnGame> game);
-
-      std::shared_ptr<RenderTarget> getBackBuffer() override;
+      RenderManager(DawnGame &game);
+      RenderTarget & getBackBuffer() override;
+      RenderPipeline & getRenderPipeline() override;
       void init() override;
       void update() override;
       

src/dawnopengl/display/StandardRenderPipeline.cpp

@@ -0,0 +1,55 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "StandardRenderPipeline.hpp"
+#include "scene/components/Components.hpp"
+
+using namespace Dawn;
+
+StandardRenderPipeline::StandardRenderPipeline(RenderManager &renderManager) :
+  RenderPipeline(renderManager)
+{
+}
+
+void StandardRenderPipeline::renderScene(Scene &scene) {
+  RenderTarget &backBuffer = this->renderManager.getBackBuffer();
+  auto cameras = scene.findComponents<Camera>();
+  std::shared_ptr<Camera> backBufferCamera = nullptr;
+
+  // First, render all non-backbuffer cameras.
+  auto it = cameras.begin();
+  while(it != cameras.end()) {
+    RenderTarget &cameraTarget = (*it)->getRenderTarget();
+
+    // Leave the backbuffer camera(s) to last, so we skip them.
+    if(&cameraTarget == &backBuffer) {
+      backBufferCamera = *it;
+    } else {
+      this->renderSceneCamera(scene, **it);
+    }
+
+    ++it;
+  }
+
+  // Now render the backbuffer camera.
+  if(backBufferCamera == nullptr) return;
+  this->renderSceneCamera(scene, *backBufferCamera);
+}
+
+void StandardRenderPipeline::renderSceneCamera(Scene &scene, Camera &camera) {
+  RenderTarget &renderTarget = camera.getRenderTarget();
+  renderTarget.bind();
+  renderTarget.clear(
+    RENDER_TARGET_CLEAR_FLAG_DEPTH |
+    RENDER_TARGET_CLEAR_FLAG_COLOR
+  );
+
+  auto meshes = scene.findComponents<MeshRenderer>();
+  auto it = meshes.begin();
+  while(it != meshes.end()) {
+    (*it)->mesh->draw(MESH_DRAW_MODE_TRIANGLES, 0, -1);
+    ++it;
+  }
+}

src/dawnopengl/display/StandardRenderPipeline.hpp

@@ -0,0 +1,18 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnopengl.hpp"
+#include "display/RenderPipeline.hpp"
+
+namespace Dawn {
+  class StandardRenderPipeline : public RenderPipeline {
+    public:
+      StandardRenderPipeline(RenderManager &renderManager);
+
+      void renderScene(Scene &scene) override;
+      void renderSceneCamera(Scene &scene, Camera &camera) override;
+  };
+}

src/dawnopengl/display/mesh/TriangleMesh.cpp

@@ -8,19 +8,19 @@
 
 using namespace Dawn;
 
-void TriangleMesh::createTriangleMesh(std::shared_ptr<Mesh> mesh) {
-  mesh->createBuffers(3, 3);
-  mesh->bufferPositions(0, std::array<glm::vec3, 3>{{
+void TriangleMesh::createTriangleMesh(Mesh &mesh) {
+  mesh.createBuffers(3, 3);
+  mesh.bufferPositions(0, std::array<glm::vec3, 3>{{
     glm::vec3(-1, 0, 0),
     glm::vec3(0, 1, 0),
     glm::vec3(1, 0, 0)
   }});
-  mesh->bufferCoordinates(0, std::array<glm::vec2, 3>{{
+  mesh.bufferCoordinates(0, std::array<glm::vec2, 3>{{
     glm::vec2(0, 0),
     glm::vec2(0, 1),
     glm::vec2(1, 0)
   }});
-  mesh->bufferIndices(0, std::array<meshindice_t,3>{{
+  mesh.bufferIndices(0, std::array<meshindice_t,3>{{
     0, 1, 2
   }});
 }