Added IRenderable, removed shader programs and allow more nuanced control of render passes, UI items are now rendered same as other scene item components.

src/dawn/display/RenderPipeline.cpp

@@ -166,62 +166,18 @@ void RenderPipeline::renderSceneCamera(Scene *scene, Camera *camera) {
   auto renderTarget = camera->getRenderTarget();
   assertNotNull(renderTarget);
 
+  // Update shader parameter buffers with current knowledge
+  this->camera = camera;
+
   // Get the list of things to render first.
   std::vector<struct ShaderPassItem> shaderPassItems;
 
-  // Meshes
-  auto meshes = scene->findComponents<MeshRenderer>();
-  auto itMesh = meshes.begin();
-  while(itMesh != meshes.end()) {
-    // Get Mesh
-    auto mesh = *itMesh;
-    assertNotNull(mesh);
-    assertNotNull(mesh->mesh);
-    
-    // Make sure this mesh has a material
-    auto mat = mesh->item->getComponent<Material>();
-    assertNotNull(mat);
-
-    auto shader = mat->getShader();
-    assertNotNull(shader);
-
-    // Now get and validate the pass items for this material/shader
-    auto materialPassItems = shader->getPassItems(mesh->mesh, mat, camera);
-    itPassItem = materialPassItems.begin();
-    while(itPassItem != materialPassItems.end()) {
-      auto item = *itPassItem;
-
-      // Validate the pass
-      assertNotNull(item.mesh);
-      assertTrue(item.start >= 0);
-      assertTrue(item.count > 0 || item.count == -1);
-      assertNotNull(item.shaderProgram);
-
-      // Queue
-      shaderPassItems.push_back(item);
-      ++itPassItem;
-    }
-    ++itMesh;
-  }
-  
-  // UI Elements
-  if(renderTarget == this->renderManager->getBackBuffer()) {
-    auto canvases = scene->findComponents<UICanvas>();
-    auto itCanvas = canvases.begin();
-    while(itCanvas != canvases.end()) {
-      auto canvas = *itCanvas;
-      glm::mat4 projection;
-      glm::mat4 view;
-      canvas->getProjectionAndView(&projection, &view);
-
-      auto renderables = canvas->item->findChildrenDeep<UIComponentRenderable>();
-      auto itChild = renderables.begin();
-      while(itChild != renderables.end()) {
-        vectorAppend(&shaderPassItems,(*itChild)->getPassItems(projection, view));
-        ++itChild;
-      }
-      ++itCanvas;
-    }
+  // Renderables
+  auto renderables = scene->findComponents<IRenderable>();
+  auto itRenderables = renderables.begin();
+  while(itRenderables != renderables.end()) {
+    vectorAppend(&shaderPassItems, (*itRenderables)->getRenderPasses());
+    ++itRenderables;
   }
 
   // Debug Lines
@@ -261,7 +217,7 @@ void RenderPipeline::renderSceneCamera(Scene *scene, Camera *camera) {
   );
 
   // Now we've sorted everything! Let's actually start rendering.
-  ShaderProgram *boundProgram = nullptr;
+  Shader *boundShader = nullptr;
   std::map<textureslot_t, Texture*> boundTextures;
   
   // TODO: This will be editable!
@@ -277,9 +233,9 @@ void RenderPipeline::renderSceneCamera(Scene *scene, Camera *camera) {
     auto item = *itPassItem;
 
     // Bind the program.
-    if(boundProgram != item.shaderProgram) {
-      boundProgram = item.shaderProgram;
-      boundProgram->bind();
+    if(boundShader != item.shader) {
+      boundShader = item.shader;
+      boundShader->bind();
     }
 
     // Bind the textures to the slots
@@ -298,37 +254,37 @@ void RenderPipeline::renderSceneCamera(Scene *scene, Camera *camera) {
     // Now set each of the parameters. Nothing exciting here.
     auto itColors = item.colorValues.begin();
     while(itColors != item.colorValues.end()) {
-      item.shaderProgram->setColor(itColors->first, itColors->second);
+      item.shader->setColor(itColors->first, itColors->second);
       ++itColors;
     }
 
     auto itBool = item.boolValues.begin();
     while(itBool != item.boolValues.end()) {
-      item.shaderProgram->setBoolean(itBool->first, itBool->second);
+      item.shader->setBoolean(itBool->first, itBool->second);
       ++itBool;
     }
 
     auto itMat = item.matrixValues.begin();
     while(itMat != item.matrixValues.end()) {
-      item.shaderProgram->setMatrix(itMat->first, itMat->second);
+      item.shader->setMatrix(itMat->first, itMat->second);
       ++itMat;
     }
 
     auto itVec3 = item.vec3Values.begin();
     while(itVec3 != item.vec3Values.end()) {
-      item.shaderProgram->setVector3(itVec3->first, itVec3->second);
+      item.shader->setVector3(itVec3->first, itVec3->second);
       ++itVec3;
     }
 
     auto itText = item.textureValues.begin();
     while(itText != item.textureValues.end()) {
-      item.shaderProgram->setTexture(itText->first, itText->second);
+      item.shader->setTexture(itText->first, itText->second);
       ++itText;
     }
 
     auto itFloat = item.floatValues.begin();
     while(itFloat != item.floatValues.end()) {
-      item.shaderProgram->setFloat(itFloat->first, itFloat->second);
+      item.shader->setFloat(itFloat->first, itFloat->second);
       ++itFloat;
     }
 

src/dawn/display/RenderPipeline.hpp

@@ -6,10 +6,10 @@
 #pragma once
 #include "dawnlibs.hpp"
 #include "scene/components/display/Material.hpp"
-#include "scene/components/display/mesh/MeshRenderer.hpp"
 #include "scene/components/display/Camera.hpp"
 #include "scene/components/scene/SubSceneController.hpp"
 #include "scene/components/ui/UIComponent.hpp"
+#include "display/shader/ShaderPass.hpp"
 
 namespace Dawn {
   class RenderManager;
@@ -21,6 +21,9 @@ namespace Dawn {
     public:
       RenderManager *renderManager;
 
+      // Temporary hack
+      Camera *camera = nullptr;
+
       /**
        * Constructs a new RenderPipeline. Render Pipelines are my attempt to
        * create both a flexible, but standard way to allow the individual games

src/dawn/display/shader/Shader.hpp

@@ -1,65 +0,0 @@
-// Copyright (c) 2023 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "display/shader/ShaderProgram.hpp"
-#include "display/mesh/Mesh.hpp"
-#include "display/_RenderManager.hpp"
-
-namespace Dawn {
-  class Material;
-  class MeshRenderer;
-  class Camera;
-
-  struct ShaderPassItem {
-    ShaderProgram *shaderProgram = nullptr;
-    int32_t priority = 0;
-
-    Mesh *mesh;
-    int32_t start = 0;
-    int32_t count = -1;
-    float_t w = 0;
-    renderflag_t renderFlags = RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST;
-    enum MeshDrawMode drawMode = MESH_DRAW_MODE_TRIANGLES;
-    
-    // Parameters
-    std::map<shaderparameter_t, struct Color> colorValues;
-    std::map<shaderparameter_t, bool_t> boolValues;
-    std::map<shaderparameter_t, glm::mat4> matrixValues;
-    std::map<shaderparameter_t, glm::vec3> vec3Values;
-    std::map<shaderparameter_t, textureslot_t> textureValues;
-    std::map<shaderparameter_t, float_t> floatValues;
-
-    // Textures
-    std::map<textureslot_t, Texture*> textureSlots;
-  };
-
-  class Shader {
-    public:
-      int32_t shaderId = -1;
-      int_fast16_t renderId = 0;
-
-      /**
-       * Compile all programs for this shader. This amy not remain forever as I
-       * may decide to allow shaders to share programs somehow. For now though
-       * this is clean enough.
-       */
-      virtual void compile() = 0;
-
-      /**
-       * Returns the list of pass items to render for the given scene item.
-       * 
-       * @param mesh Mesh Renderer for the scene item.
-       * @param material Material for the scene item.
-       * @param camera Camera for the scene.
-       * @return List of passes to render.
-       */
-      virtual std::vector<struct ShaderPassItem> getPassItems(
-        Mesh *mesh,
-        Material *material,
-        Camera *camera
-      ) = 0;
-  };
-}

src/dawn/display/shader/ShaderPass.hpp

@@ -0,0 +1,33 @@
+// Copyright (c) 2023 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/shader/Shader.hpp"
+#include "display/mesh/Mesh.hpp"
+
+namespace Dawn {
+  struct ShaderPassItem {
+    Shader *shader = nullptr;
+    int32_t priority = 0;
+
+    Mesh *mesh;
+    int32_t start = 0;
+    int32_t count = -1;
+    float_t w = 0;
+    renderflag_t renderFlags = RENDER_MANAGER_RENDER_FLAG_DEPTH_TEST;
+    enum MeshDrawMode drawMode = MESH_DRAW_MODE_TRIANGLES;
+    
+    // Parameters
+    std::map<shaderparameter_t, struct Color> colorValues;
+    std::map<shaderparameter_t, bool_t> boolValues;
+    std::map<shaderparameter_t, glm::mat4> matrixValues;
+    std::map<shaderparameter_t, glm::vec3> vec3Values;
+    std::map<shaderparameter_t, textureslot_t> textureValues;
+    std::map<shaderparameter_t, float_t> floatValues;
+
+    // Textures
+    std::map<textureslot_t, Texture*> textureSlots;
+  };
+}

src/dawn/display/shader/_Shader.hpp

@@ -1,16 +1,26 @@
-// Copyright (c) 2022 Dominic Masters
+// Copyright (c) 2023 Dominic Masters
 // 
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
 #pragma once
+#include "display/mesh/Mesh.hpp"
+#include "display/_RenderManager.hpp"
 #include "display/Texture.hpp"
 #include "display/shader/ShaderParameterBuffer.hpp"
 
 namespace Dawn {
   template<typename T>
-  class IShaderProgram {
+  class IShader {
     public:
+      int32_t shaderId = -1;
+      int_fast16_t renderId = 0;
+      
+      /**
+       * Compile all programs for this shader. 
+       */
+      virtual void compile() = 0;
+
       /**
        * Attaches the supplied shader as the current shader.
        */
@@ -72,5 +82,6 @@ namespace Dawn {
        * @param Float to bind.
        */
       virtual void setFloat(T parameter, float_t value) = 0;
+
   };
 }