Documenting done.

src/dawnopengl/display/BackBufferRenderTarget.hpp

@@ -18,15 +18,28 @@ namespace Dawn {
       struct Color clearColor = COLOR_CORNFLOWER_BLUE;
 
     public:
+      /**
+       * Construct the back buffer render target.
+       * 
+       * @param renderManager Render Manager for this back buffer target.
+       */
       BackBufferRenderTarget(RenderManager &renderManager);
 
+      /**
+       * Requests to modify the viewport directly. This is mostly to be called
+       * by whatever is setting the window/display resolution, so that the
+       * backbuffer can keep track of what the viewport size is. This should
+       * also be DPI aware, e.g. "4k @ 2xDPI, resulting in a 1080p equiv" should
+       * still call this method with 3840, 2160.
+       * 
+       * @param width New width of the back buffer.
+       * @param height New height of the back buffer.
+       */
+      void setSize(float_t width, float_t height);
+
       float_t getWidth() override;
       float_t getHeight() override;
-
-      void setSize(float_t width, float_t height);
-
-      void setClearColor(struct Color color);
-
+      void setClearColor(struct Color color) override;
       void clear(flag8_t clearFlags) override;
       void bind() override;
   };

src/dawnopengl/display/StandardRenderPipeline.cpp

@@ -11,60 +11,4 @@ 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()) {
-    auto mesh = *it;
-    auto item = mesh->item;
-    auto material = item.getComponent<Material>();
-
-    // TODO: fallback material?
-    if(material == nullptr) {
-      continue;
-    }
-
-    auto shader = material->getShader();
-    shader->bind();
-    shader->setGlobalParameters(camera.projection, camera.item.transform);
-    shader->setMeshParameters(item.transform);
-    material->setShaderParameters();
-
-    mesh->mesh->draw(MESH_DRAW_MODE_TRIANGLES, 0, -1);
-    ++it;
-  }
 }

src/dawnopengl/display/StandardRenderPipeline.hpp

@@ -11,8 +11,5 @@ 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/shader/Shader.hpp

@@ -23,10 +23,14 @@ namespace Dawn {
       GLuint shaderProgram = -1;
 
     protected:
-      void compileShader(
-        std::string vertexShader,
-        std::string fragmentShader
-      );
+      /**
+       * Compiles a GLSL shader and stores it on the GPU, updates the underlying
+       * pointers for you.
+       * 
+       * @param vertexShader The string source of the vertex shader.
+       * @param fragmentShader The string source of the fragment shader.
+       */
+      void compileShader(std::string vertexShader, std::string fragmentShader);
 
     public:
       /**
@@ -37,13 +41,21 @@ namespace Dawn {
        */
       shaderparameter_t getParameterByName(std::string name);
 
-      void bind() override;
+      /**
+       * Method to request that this shader be compiled and put on the GPU. This
+       * method should call the protected compileShader method.
+       */
       virtual void compile() = 0;
+
+      void bind() override;
       void setMatrix(shaderparameter_t parameter, glm::mat4 matrix) override;
       void setBoolean(shaderparameter_t parameter, bool_t value) override;
       void setColor(shaderparameter_t parameter, struct Color color) override;
       void setVector3(shaderparameter_t parameter, glm::vec3 vector) override;
 
-      ~Shader();
+      /**
+       * Destroys and deletes the shader from the GPU.
+       */
+      virtual ~Shader();
   };
 }

src/dawnopengl/display/shader/SimpleTexturedShader.hpp

@@ -23,8 +23,8 @@ namespace Dawn {
         std::map<shaderparameter_t, enum ShaderParameterType> ps;
 
         ps[this->paramColor] = SHADER_PARAMETER_TYPE_COLOR;
+        ps[this->paramHasTexture] = SHADER_PARAMETER_TYPE_BOOLEAN;
         // ps[paramTexture] SHADER_PARAMETER_TYPE_TEXTURE;
-        // ps[this->paramHasTexture] = SHADER_PARAMETER_TYPE_BOOLEAN;
 
         return ps;
       }