prog

assets/shaders/hello-world.slang

@@ -1,11 +1,9 @@
-struct Uniforms {
+uniform float4x4 u_Projection;
-  float4x4 projection;
+uniform float4x4 u_View;
-  float4x4 view;
+uniform float4x4 u_Model;
-  float4x4 model;
+uniform float4 u_Color;
-  float4 u_Color;
+uniform bool u_HasTexture;
-  bool u_HasTexture;
+uniform Sampler2D u_Texture;
-  Sampler2D u_Texture;
-};
 
 struct AssembledVertex {
   float3 position : POSITION;
@@ -25,8 +23,6 @@ float4 someFunction(float4 color) {
   return color * float4(0.5, 0.5, 0.5, 1.0);
 }
 
-uniform ParameterBlock<Uniforms> uniforms;
-
 [shader("vertex")]
 VertexStageOutput vertexMain(
   AssembledVertex assembledVertex
@@ -39,7 +35,7 @@ VertexStageOutput vertexMain(
 
   output.sv_position = mul(
     float4(position, 1.0),
-    mul(uniforms.model, mul(uniforms.view, uniforms.projection))
+    mul(u_Model, mul(u_View, u_Projection))
   );
 
   return output;
@@ -50,10 +46,10 @@ Fragment fragmentMain(
   float2 uv: UV
 ) : SV_Target {
   Fragment output;
-  if(uniforms.u_HasTexture) {
+  if(u_HasTexture) {
-    output.color = uniforms.u_Texture.Sample(uv) * uniforms.u_Color;
+    output.color = u_Texture.Sample(uv) * u_Color;
   } else {
-      output.color = someFunction(uniforms.u_Color);
+      output.color = someFunction(u_Color);
   }
   return output;
 }

src/dawn/component/display/material/SimpleTexturedMaterial.hpp

@@ -5,17 +5,29 @@
 
 #pragma once
 #include "component/display/material/Material.hpp"
-#include "display/Texture.hpp"
+#include "display/shader/ShaderData.hpp"
 
 namespace Dawn {
-  struct SimpleTexturedMaterialShaderData {
+  struct SimpleTexturedMaterialShaderData : public ShaderData {
-    int32_t t;
+    protected:
-    struct Color color;
+      void writeData() override {
-    glm::mat4 model;
+        this->beginStruct();
-    glm::mat4 projection;
+        // this->writeMat4(this->projection);
-    glm::mat4 view;
+        // this->writeMat4(this->view);
-    bool hasTexture;
+        // this->writeMat4(this->model);
-    std::shared_ptr<Texture> texture;
+        // this->writeColor(this->color);
+        // this->writeBoolean(this->hasTexture);
+        // this->writeTexture(this->texture);
+        this->endStruct();
+      }
+
+    public:
+      struct Color color;
+      glm::mat4 model;
+      glm::mat4 projection;
+      glm::mat4 view;
+      bool hasTexture;
+      std::shared_ptr<Texture> texture;
   };
 
   class SimpleTexturedMaterial : public Material {

src/dawn/display/shader/CMakeLists.txt

@@ -6,9 +6,9 @@
 # Sources
 target_sources(${DAWN_TARGET_NAME}
   PRIVATE
-    IShaderProgram.cpp
-    IShaderStage.cpp
     ShaderManager.cpp
     ShaderManagerSlangFileSystem.cpp
+    IShaderStage.cpp
     IShaderProgram.cpp
+    IShaderData.cpp
 )

src/dawn/display/shader/IShaderData.cpp

@@ -0,0 +1,20 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "IShaderData.hpp"
+#include "assert/assert.hpp"
+
+using namespace Dawn;
+
+void IShaderData::write(std::shared_ptr<ShaderProgram> shader) {
+  assertNotNull(shader, "Shader cannot be null.");
+  this->shader = shader;
+  this->writeData();
+  this->shader = nullptr;
+}
+
+std::shared_ptr<ShaderProgram> IShaderData::getShader() {
+  return this->shader;
+}

src/dawn/display/shader/IShaderData.hpp

@@ -0,0 +1,42 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/Texture.hpp"
+#include "display/shader/ShaderProgram.hpp"
+
+namespace Dawn {
+  class IShaderData {
+    private:
+      std::shared_ptr<ShaderProgram> shader;
+
+    protected:
+      virtual void writeData() = 0;
+
+      virtual void beginStruct() = 0;
+      virtual void writeMat4(const glm::mat4 &mat) = 0;
+      virtual void writeVec3(const glm::vec3 &vec) = 0;
+      virtual void writeVec4(const glm::vec4 &vec) = 0;
+      virtual void writeColor(const struct Color &color) = 0;
+      virtual void writeBoolean(const bool &value) = 0;
+      virtual void writeTexture(std::shared_ptr<Texture> &texture) = 0;
+      virtual void endStruct() = 0;
+
+    public:
+      /**
+       * Writes the data to the shader.
+       * 
+       * @param shader The shader to write to.
+       */
+      void write(std::shared_ptr<ShaderProgram> shader);
+
+      /**
+       * Returns the shader that was written to.
+       * 
+       * @return The shader that was written to.
+       */
+      std::shared_ptr<ShaderProgram> getShader();
+  };
+}

src/dawnopengl/display/shader/CMakeLists.txt

@@ -8,4 +8,5 @@ target_sources(${DAWN_TARGET_NAME}
   PRIVATE
     ShaderProgram.cpp
     ShaderStage.cpp
+    ShaderData.cpp
 )

src/dawnopengl/display/shader/ShaderData.cpp

@@ -0,0 +1,63 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "ShaderData.hpp"
+#include "assert/assert.hpp"
+#include "assert/assertgl.hpp"
+
+using namespace Dawn;
+
+void ShaderData::beginStruct() {
+  // Do nothing
+}
+
+void ShaderData::writeMat4(const glm::mat4 &mat) {
+  char_t name[1024];
+  GLsizei length;
+  GLint size;
+  GLenum type;
+  glGetActiveUniform(getShader()->id, i, sizeof(name), &length, &size, &type, name);
+  assertNoGLError();
+  std::cout << "Uniform: " << name << std::endl;
+
+  glUniformMatrix4fv(this->i, 1, GL_FALSE, glm::value_ptr(mat));
+  assertNoGLError();
+  this->i++;
+}
+
+void ShaderData::writeVec3(const glm::vec3 &vec) {
+  assertUnreachable("Not implemented");
+}
+
+void ShaderData::writeVec4(const glm::vec4 &vec) {
+  assertUnreachable("Not implemented");
+}
+
+void ShaderData::writeColor(const struct Color &color) {
+  glUniform4fv(this->i, 1, &color.r);
+  assertNoGLError();
+  this->i++;
+}
+
+void ShaderData::writeBoolean(const bool &value) {
+  glUniform1i(this->i, value ? 1 : 0);
+  assertNoGLError();
+  this->i++;
+}
+
+void ShaderData::writeTexture(std::shared_ptr<Texture> &texture) {
+  if(texture == nullptr) {
+    this->i++;
+    return;
+  }
+  texture->bind(0);
+  glUniform1i(this->i, 0);
+  assertNoGLError();
+  this->i++;
+}
+
+void ShaderData::endStruct() {
+  // Do nothing
+}

src/dawnopengl/display/shader/ShaderData.hpp

@@ -0,0 +1,24 @@
+// Copyright (c) 2024 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#pragma once
+#include "display/shader/IShaderData.hpp"
+
+namespace Dawn {
+  class ShaderData : public IShaderData {
+    private:
+      int32_t i = 0;
+      
+    protected:
+      void beginStruct() override;
+      void writeMat4(const glm::mat4 &mat) override;
+      void writeVec3(const glm::vec3 &vec) override;
+      void writeVec4(const glm::vec4 &vec) override;
+      void writeColor(const struct Color &color) override;
+      void writeBoolean(const bool &value) override;
+      void writeTexture(std::shared_ptr<Texture> &texture) override;
+      void endStruct() override;
+  };
+}

src/dawnopengl/display/shader/ShaderProgram.cpp

@@ -7,6 +7,7 @@
 #include "assert/assert.hpp"
 #include "assert/assertgl.hpp"
 
+#include "component/display/material/SimpleTexturedMaterial.hpp"
 
 using namespace Dawn;
 
@@ -50,31 +51,43 @@ void ShaderProgram::init(
   // So the uniforms that are in slang are kinda odd when compiled.
 
   //DEBUGGING
-  GLint numUniforms = 0;
+  // GLint numUniforms = 0;
-  glGetProgramiv(this->id, GL_ACTIVE_UNIFORMS, &numUniforms);
+  // glGetProgramiv(this->id, GL_ACTIVE_UNIFORMS, &numUniforms);
+  // assertNoGLError();
+
+  // for(GLint i = 0; i < numUniforms; ++i) {
+  //   char name[1024];
+  //   GLsizei length;
+  //   GLint size;
+  //   GLenum type;
+
+  //   glGetActiveUniform(this->id, i, sizeof(name), &length, &size, &type, name);
+  //   assertNoGLError();
+  //   std::cout << "Uniform: " << i << ": " << name << " has size " << size << " and length " << length << std::endl;
+  // }
+  // GLint numUniformBlocks = 0;
+  // glGetProgramiv(this->id, GL_ACTIVE_UNIFORM_BLOCKS, &numUniformBlocks);
+
+  // for(GLint i = 0; i < numUniformBlocks; ++i) {
+  //   GLint size;
+  //   glGetActiveUniformBlockiv(this->id, i, GL_UNIFORM_BLOCK_DATA_SIZE, &size);
+  //   assertNoGLError();
+  //   std::cout << "Uniform Block: " << i << " has size " << size << std::endl;
+  // }
+
+  glUseProgram(this->id);
   assertNoGLError();
 
-  for(GLint i = 0; i < numUniforms; ++i) {
+  auto data = std::make_shared<SimpleTexturedMaterialShaderData>();
-    char name[1024];
+  data->color = COLOR_WHITE;
-    GLsizei length;
+  data->model = glm::mat4(1.0f);
-    GLint size;
+  data->projection = glm::perspective(
-    GLenum type;
+    glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 100.0f
-
+  );
-    glGetActiveUniform(this->id, i, sizeof(name), &length, &size, &type, name);
+  data->view = glm::lookAt(
-    assertNoGLError();
+    glm::vec3(4,3,3), glm::vec3(0,0,0), glm::vec3(0,1,0)
-    std::cout << "Uniform: " << i << ": " << name << " has size " << size << " and length " << length << std::endl;
+  );
-  }
+  data->write(shared_from_this());
-
-
-  GLint numUniformBlocks = 0;
-  glGetProgramiv(this->id, GL_ACTIVE_UNIFORM_BLOCKS, &numUniformBlocks);
-
-  for(GLint i = 0; i < numUniformBlocks; ++i) {
-    GLint size;
-    glGetActiveUniformBlockiv(this->id, i, GL_UNIFORM_BLOCK_DATA_SIZE, &size);
-    assertNoGLError();
-    std::cout << "Uniform Block: " << i << " has size " << size << std::endl;
-  }
 }
 
 ShaderProgram::~ShaderProgram() {

src/dawnopengl/display/shader/ShaderProgram.hpp

@@ -8,7 +8,12 @@
 #include "dawnopengl.hpp"
 
 namespace Dawn {
-  class ShaderProgram : public IShaderProgram {
+  class ShaderData;
+  
+  class ShaderProgram :
+    public IShaderProgram,
+    public std::enable_shared_from_this<ShaderProgram>
+  {
     private:
       GLuint id = -1;
 
@@ -17,5 +22,7 @@ namespace Dawn {
         const std::vector<std::shared_ptr<ShaderStage>> &stages
       ) override;
       ~ShaderProgram();
+
+      friend class ShaderData;
   };
 }