Material

src/dawn/display/Shader.hpp

@@ -1,11 +0,0 @@
-// Copyright (c) 2022 Dominic Masters
-// 
-// This software is released under the MIT License.
-// https://opensource.org/licenses/MIT
-
-#pragma once
-#include "dawnlibs.hpp"
-
-namespace Dawn {
-  class Shader;
-}

src/dawn/display/_RenderManager.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 #include "RenderTarget.hpp"
+#include "display/shader/Shader.hpp"
 
 namespace Dawn {
   class DawnGame;
@@ -30,8 +31,22 @@ namespace Dawn {
        */
       virtual RenderTarget & getBackBuffer() = 0;
 
+      /**
+       * Returns the current render pipeline intended to be used for rendering
+       * the currently active scene on the game instance.
+       * 
+       * @return Reference to the currently active main scene render pipeline.
+       */
       virtual RenderPipeline & getRenderPipeline() = 0;
 
+      /**
+       * Returns the default shader, the default shader will be applied to the
+       * materials first.
+       * 
+       * @return Reference to the default shader.
+       */
+      virtual std::shared_ptr<Shader> getDefaultShader() = 0;
+
       /**
        * Initialize / Start the Render Manager.
        * 
@@ -43,5 +58,7 @@ namespace Dawn {
        * Perform a synchronous frame update on the render manager.
        */
       virtual void update() = 0;
+
+
   };
 }

src/dawn/display/shader/_Shader.hpp

@@ -0,0 +1,80 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "dawnlibs.hpp"
+
+namespace Dawn {
+  class Material;
+
+  enum ShaderParameterType {
+    SHADER_PARAMETER_TYPE_MATRIX,
+    SHADER_PARAMETER_TYPE_BOOLEAN,
+    SHADER_PARAMETER_TYPE_COLOR,
+    SHADER_PARAMETER_TYPE_VECTOR3
+  };
+
+  template<typename T>
+  class IShader {
+    public:
+      /**
+       * Attaches the supplied shader as the current shader.
+       */
+      virtual void bind() = 0;
+
+      // virtual void setCamera(glm::mat4 projection, glm::mat4 view) = 0;
+      // virtual void setLocalPosition(glm::mat4 position) = 0;
+
+      virtual void setDefaultParameters(Material &material) = 0;
+
+      virtual void setGlobalParameters(
+        glm::mat4 projection,
+        glm::mat4 view
+      ) = 0;
+
+      virtual void setMeshParameters(glm::mat4 position) = 0;
+
+      /**
+       * Retreives the list of all parameters that the shader supports. This 
+       * should not include the GLOBAL shader parameters (listed above) since 
+       * those will be modified by the engine directly.
+       * 
+       * @return Key-Value-Pair of Shader parameters and their type.
+       */
+      virtual std::map<T, enum ShaderParameterType> getParameters() = 0;
+
+      /**
+       * Set's a specific shader parameter to a matrix.
+       * 
+       * @param parameter parameter on the shader to set.
+       * @param matrix Matrix to apply.
+       */
+      virtual void setMatrix(T parameter, glm::mat4 matrix) = 0;
+
+      /**
+       * Attaches a boolean to a shader.
+       * 
+       * @param parameter parameter to set.
+       * @param value Value to set.
+       */
+      virtual void setBoolean(T parameter, bool_t value) = 0;
+
+      /**
+       * Set a color on to the shader.
+       * 
+       * @param parameter parameter to set the color to.
+       * @param color Color to set.
+       */
+      virtual void setColor(T parameter, struct Color color) = 0;
+
+      /**
+       * Set a 3D vector on to the shader.
+       * 
+       * @param parameter parameter to set the vector to.
+       * @param vector Vector to set.
+       */
+      virtual void setVector3(T parameter, glm::vec3 vector) = 0;
+  };
+}

src/dawn/scene/SceneItem.cpp

@@ -10,9 +10,11 @@ using namespace Dawn;
 
 SceneItem::SceneItem(Scene &scene, sceneitemid_t id) :
   scene(scene),
-  id(id)
+  id(id),
+  transform(1.0f)
 {
   this->id = id;
+  this->transform = glm::translate(this->transform, glm::vec3(0, 0, 0));
 }
 
 void SceneItem::init() {

src/dawn/scene/SceneItem.hpp

@@ -18,6 +18,7 @@ namespace Dawn {
     public:
       Scene &scene;
       sceneitemid_t id;
+      glm::mat4 transform;
 
       /**
        * Constructor for a SceneItem. Scene Items should only be called and

src/dawn/scene/components/Components.hpp

@@ -6,4 +6,5 @@
 #pragma once
 #include "scene/components/DummyComponent.hpp"
 #include "scene/components/display/Camera.hpp"
-#include "scene/components/display/MeshRenderer.hpp"
+#include "scene/components/display/MeshRenderer.hpp"
+#include "scene/components/display/Material.hpp"

src/dawn/scene/components/display/CMakeLists.txt

@@ -7,5 +7,6 @@
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     Camera.cpp
+    Material.cpp
     MeshRenderer.cpp
 )

src/dawn/scene/components/display/Camera.cpp

@@ -12,6 +12,7 @@ using namespace Dawn;
 Camera::Camera(SceneItem &item) :
   SceneItemComponent(item)
 {
+  this->updateProjection();
 }
 
 void Camera::updateProjection() {
@@ -38,6 +39,14 @@ void Camera::updateProjection() {
   }
 }
 
+void Camera::lookAt(glm::vec3 pos, glm::vec3 look) {
+  this->lookAt(pos, look, glm::vec3(0, 1, 0));
+}
+
+void Camera::lookAt(glm::vec3 pos, glm::vec3 look, glm::vec3 up) {
+  this->item.transform = glm::lookAt(pos, look, up);
+}
+
 RenderTarget & Camera::getRenderTarget() {
   if(this->target == nullptr) {
     return this->getGame().renderManager.getBackBuffer();

src/dawn/scene/components/display/Camera.hpp

@@ -44,6 +44,16 @@ namespace Dawn {
        */
       void updateProjection();
 
+      void lookAt(glm::vec3 position, glm::vec3 look);
+
+      void lookAt(glm::vec3 position, glm::vec3 look, glm::vec3 up);
+
+      /**
+       * Returns the intended render target for this camera to render to, will
+       * automatically revert to the back buffer if no frame buffer is provided.
+       * 
+       * @return The target render target framebuffer.
+       */
       RenderTarget & getRenderTarget();
 
       /**

src/dawn/scene/components/display/Material.cpp

@@ -0,0 +1,68 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "Material.hpp"
+#include "scene/Scene.hpp"
+#include "game/DawnGame.hpp"
+
+using namespace Dawn;
+
+Material::Material(SceneItem &item) : 
+  SceneItemComponent(item),
+  shader(item.scene.game.renderManager.getDefaultShader())
+{
+  this->updateShaderParameters();
+}
+
+void Material::updateShaderParameters() {
+  std::cout << "Updating params" << std::endl;
+  this->colorValues.clear();
+  this->boolValues.clear();
+
+  this->parameters = this->shader->getParameters();
+  this->shader->setDefaultParameters(*this);
+
+  // We do need to validate these params at some point to make sure that the
+  // shader has actually bound them.
+}
+
+void Material::setShaderParameters() {
+  auto it = this->parameters.begin();
+  while(it != this->parameters.end()) {
+    switch(it->second) {
+      case SHADER_PARAMETER_TYPE_COLOR:
+        this->shader->setColor(it->first, this->colorValues[it->first]);
+        break;
+
+      case SHADER_PARAMETER_TYPE_MATRIX:
+        this->shader->setMatrix(it->first, this->matrixValues[it->first]);
+        break;
+
+      case SHADER_PARAMETER_TYPE_BOOLEAN:
+        this->shader->setBoolean(it->first, this->boolValues[it->first]);
+        break;
+
+      case SHADER_PARAMETER_TYPE_VECTOR3:
+        this->shader->setVector3(it->first, this->vec3Values[it->first]);
+        break;
+
+      default:
+        throw "An unsupported or invalid shader parameter type was supplied.";
+    }
+    ++it;
+  }
+}
+
+std::shared_ptr<Shader> Material::getShader() {
+  return this->shader;
+}
+
+void Material::setShader(std::shared_ptr<Shader> shader) {
+  this->shader = shader;
+  this->updateShaderParameters();
+}
+
+void Material::start() {
+}

src/dawn/scene/components/display/Material.hpp

@@ -0,0 +1,39 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "scene/SceneItemComponent.hpp"
+#include "display/shader/Shader.hpp"
+
+namespace Dawn {
+  class Shader;
+  
+  class Material : public SceneItemComponent {
+    friend class RenderPipeline;
+
+    private:
+      std::shared_ptr<Shader> shader;
+
+      void updateShaderParameters();
+
+
+    public:
+      std::map<shaderparameter_t, enum ShaderParameterType> 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;
+
+      Material(SceneItem &item);
+
+      std::shared_ptr<Shader> getShader();
+      void setShader(std::shared_ptr<Shader> shader);
+
+      void setShaderParameters();
+
+      void start() override;
+  };
+}