Material

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;
+  };
+}