almost done with ShaderData

assets/shaders/hello-world.slang

@@ -1,18 +1,13 @@
-struct Transforms {
+struct Uniforms {
   float4x4 projection;
   float4x4 view;
   float4x4 model;
-}
+  float4 color;
-
-struct Colors {
   bool hasTexture;
-  float4 colors[4];
-  int somethingElse;
   Sampler2D texture;
 }
 
-uniform Transforms transforms;
+uniform Uniforms uniforms;
-uniform Colors colors;
 
 struct AssembledVertex {
   float3 position : POSITION;
@@ -40,7 +35,7 @@ VertexStageOutput vertexMain(
 
   output.sv_position = mul(
     float4(position, 1.0),
-    mul(transforms.model, mul(transforms.view, transforms.projection))
+    mul(uniforms.model, mul(uniforms.view, uniforms.projection))
   );
 
   return output;
@@ -51,10 +46,11 @@ Fragment fragmentMain(
   float2 uv: UV
 ) : SV_Target {
   Fragment output;
-  if (colors.hasTexture) {
+  if (uniforms.hasTexture) {
-      output.color = colors.texture.Sample(uv) * colors.colors[0];
+    output.color = uniforms.texture.Sample(uv) * uniforms.color;
   } else {
-      output.color = colors.colors[0] - float4(colors.somethingElse, 0, 0, 0);
+    output.color = uniforms.color;
   }
+  
   return output;
 }

src/dawn/display/shader/IShaderData.cpp

@@ -13,6 +13,206 @@ IShaderData::IShaderData(
   data = (void *)malloc(structure->size);
 }
 
+template<>
+void *IShaderData::get<void *>(const size_t offset) {
+  return (void *)((size_t)data + offset);
+}
+
+template<>
+int8_t IShaderData::get<int8_t>(const size_t offset) {
+  return *(int8_t*)this->get<void*>(offset);
+}
+
+template<>
+int16_t IShaderData::get<int16_t>(const size_t offset) {
+  return *(int16_t *)this->get<void *>(offset);
+}
+
+template<>
+int32_t IShaderData::get<int32_t>(const size_t offset) {
+  return *(int32_t *)this->get<void *>(offset);
+}
+
+template<>
+int64_t IShaderData::get<int64_t>(const size_t offset) {
+  return *(int64_t *)this->get<void *>(offset);
+}
+
+template<>
+uint8_t IShaderData::get<uint8_t>(const size_t offset) {
+  return *(uint8_t *)this->get<void *>(offset);
+}
+
+template<>
+uint16_t IShaderData::get<uint16_t>(const size_t offset) {
+  return *(uint16_t *)this->get<void *>(offset);
+}
+
+template<>
+uint32_t IShaderData::get<uint32_t>(const size_t offset) {
+  return *(uint32_t *)this->get<void *>(offset);
+}
+
+template<>
+uint64_t IShaderData::get<uint64_t>(const size_t offset) {
+  return *(uint64_t *)this->get<void *>(offset);
+}
+
+template<>
+float_t IShaderData::get<float_t>(const size_t offset) {
+  return *(float_t *)this->get<void *>(offset);
+}
+
+template<>
+glm::vec2 IShaderData::get<glm::vec2>(const size_t offset) {
+  return *(glm::vec2 *)this->get<void *>(offset);
+}
+
+template<>
+glm::vec3 IShaderData::get<glm::vec3>(const size_t offset) {
+  return *(glm::vec3 *)this->get<void *>(offset);
+}
+
+template<>
+glm::vec4 IShaderData::get<glm::vec4>(const size_t offset) {
+  return *(glm::vec4 *)this->get<void *>(offset);
+}
+
+template<>
+glm::mat2 IShaderData::get<glm::mat2>(const size_t offset) {
+  return *(glm::mat2 *)this->get<void *>(offset);
+}
+
+template<>
+glm::mat3 IShaderData::get<glm::mat3>(const size_t offset) {
+  return *(glm::mat3 *)this->get<void *>(offset);
+}
+
+template<>
+glm::mat4 IShaderData::get<glm::mat4>(const size_t offset) {
+  return *(glm::mat4 *)this->get<void *>(offset);
+}
+
+template<>
+bool_t IShaderData::get<bool_t>(const size_t offset) {
+  return this->get<int32_t>(offset) != 0;
+}
+
+template<>
+struct Color IShaderData::get<struct Color>(const size_t offset) {
+  glm::vec4 v = this->get<glm::vec4>(offset);
+  return {
+    v.r,
+    v.g,
+    v.b,
+    v.a
+  };
+}
+
+
+
+void IShaderData::setRaw(
+  const size_t offset,
+  const void *value,
+  const size_t size
+) {
+  memcpy(this->get<void *>(offset), value, size);
+  this->dirty = true;
+}
+
+template<>
+void IShaderData::set<int8_t>(const size_t offset, const int8_t value) {
+  this->setRaw(offset, &value, sizeof(int8_t));
+}
+
+template<>
+void IShaderData::set<int16_t>(const size_t offset, const int16_t value) {
+  this->setRaw(offset, &value, sizeof(int16_t));
+}
+
+template<>
+void IShaderData::set<int32_t>(const size_t offset, const int32_t value) {
+  this->setRaw(offset, &value, sizeof(int32_t));
+}
+
+template<>
+void IShaderData::set<int64_t>(const size_t offset, const int64_t value) {
+  this->setRaw(offset, &value, sizeof(int64_t));
+}
+
+template<>
+void IShaderData::set<uint8_t>(const size_t offset, const uint8_t value) {
+  this->setRaw(offset, &value, sizeof(uint8_t));
+}
+
+template<>
+void IShaderData::set<uint16_t>(const size_t offset, const uint16_t value) {
+  this->setRaw(offset, &value, sizeof(uint16_t));
+}
+
+template<>
+void IShaderData::set<uint32_t>(const size_t offset, const uint32_t value) {
+  this->setRaw(offset, &value, sizeof(uint32_t));
+}
+
+template<>
+void IShaderData::set<uint64_t>(const size_t offset, const uint64_t value) {
+  this->setRaw(offset, &value, sizeof(uint64_t));
+}
+
+template<>
+void IShaderData::set<float_t>(const size_t offset, const float_t value) {
+  this->setRaw(offset, &value, sizeof(float_t));
+}
+
+template<>
+void IShaderData::set<glm::vec2>(const size_t offset, const glm::vec2 value) {
+  this->setRaw(offset, &value, sizeof(glm::vec2));
+}
+
+template<>
+void IShaderData::set<glm::vec3>(const size_t offset, const glm::vec3 value) {
+  this->setRaw(offset, &value, sizeof(glm::vec3));
+}
+
+template<>
+void IShaderData::set<glm::vec4>(const size_t offset, const glm::vec4 value) {
+  this->setRaw(offset, &value, sizeof(glm::vec4));
+}
+
+template<>
+void IShaderData::set<glm::mat2>(const size_t offset, const glm::mat2 value) {
+  this->setRaw(offset, &value, sizeof(glm::mat2));
+}
+
+template<>
+void IShaderData::set<glm::mat3>(const size_t offset, const glm::mat3 value) {
+  this->setRaw(offset, &value, sizeof(glm::mat3));
+}
+
+template<>
+void IShaderData::set<glm::mat4>(const size_t offset, const glm::mat4 value) {
+  this->setRaw(offset, &value, sizeof(glm::mat4));
+}
+
+template<>
+void IShaderData::set<struct Color>(
+  const size_t offset,
+  const struct Color value
+) {
+  this->set<glm::vec4>(offset, glm::vec4(
+    value.r,
+    value.g,
+    value.b,
+    value.a
+  ));
+}
+
+template<>
+void IShaderData::set<bool_t>(const size_t offset, const bool_t value) {
+  this->set<>(offset, value ? 1 : 0);
+}
+
 IShaderData::~IShaderData() {
   if(data != nullptr) {
     free(data);

src/dawn/display/shader/IShaderData.hpp

@@ -5,19 +5,55 @@
 
 #pragma once
 #include "display/Texture.hpp"
-#include "display/shader/ShaderProgram.hpp"
+#include "display/shader/ShaderStructure.hpp"
 
 namespace Dawn {
   struct IShaderData {
     protected:
-      std::shared_ptr<ShaderStructure> structure;
       void *data = nullptr;
+      bool_t dirty = true;
 
     public:
+      std::shared_ptr<ShaderStructure> structure;
+
+      /**
+       * Constructs the ShaderData object
+       * 
+       * @param structure The structure to base this data on.
+       */
       IShaderData(
         const std::shared_ptr<ShaderStructure> &structure
       );
 
+      /**
+       * Gets the value out of the data by the offset.
+       * 
+       * @param offset The offset to get the value from.
+       * @return The value at the offset.
+       */
+      template<typename T>
+      T get(const size_t offset);
+
+      /**
+       * Gets the value out of the data by the offset.
+       * 
+       * @param offset The offset to get the value from.
+       * @return The value at the offset.
+       */
+      void setRaw(const size_t offset, const void *value, const size_t size);
+
+      /**
+       * Sets the value in the data by the offset.
+       * 
+       * @param offset The offset to set the value at.
+       * @param value The value to set at the offset.
+       */
+      template<typename T>
+      void set(const size_t offset, const T value);
+
+      /**
+       * Cleans up the data.
+       */
       virtual ~IShaderData();
   };
 }

src/dawn/display/shader/IShaderProgram.cpp

@@ -123,9 +123,10 @@ void IShaderProgram::init(
 
   // Now we can really begin parsing out the data.
   structure = std::make_shared<struct ShaderStructure>(
-    realRootLayout
+    realRootLayout->getTypeLayout(),
+    "root",
+    0
   );
-  assertTrue(structure->name == "", "Root structure should not have a name.");
 }
 
 IShaderProgram::~IShaderProgram() {

src/dawn/display/shader/IShaderProgram.hpp

@@ -5,7 +5,7 @@
 
 #pragma once
 #include "display/shader/ShaderStage.hpp"
-#include "display/shader/ShaderStructure.hpp"
+#include "display/shader/ShaderData.hpp"
 
 namespace Dawn {
 

src/dawn/display/shader/ShaderStructure.cpp

@@ -9,10 +9,13 @@
 
 using namespace Dawn;
 
-ShaderStructure::ShaderStructure(VariableLayoutReflection *reflection) {
+ShaderStructure::ShaderStructure(
-  auto typeLayout = reflection->getTypeLayout();
+  TypeLayoutReflection *typeLayout,
-  auto cName = reflection->getName();
+  const std::string name,
-  this->name = cName ? std::string(cName) : "";
+  const size_t start
+) {
+  this->name = name;
+  this->start = start;
   this->size = typeLayout->getSize();
   this->alignment = typeLayout->getAlignment();
 
@@ -23,18 +26,30 @@ ShaderStructure::ShaderStructure(VariableLayoutReflection *reflection) {
       size_t offset = this->start;
       for(auto i = 0; i < count; i++) {
         auto field = typeLayout->getFieldByIndex(i);
-        ShaderStructure member(field);
+        auto cName = field->getName();
-        member.start = offset;
+        auto member = std::make_shared<ShaderStructure>(
-        offset += member.size;
+          field->getTypeLayout(),
+          cName ? std::string(cName) : "",
+          offset
+        );
+        offset += member->size;
         this->members.push_back(member);
       }
-      assertTrue(offset == this->size, "Struct size/offset mismatch?");
       break;
     }
 
     case TypeReflection::Kind::Array: {
       this->type = ShaderStructureType::ARRAY;
       this->length = typeLayout->getElementCount();
+      auto elementType = typeLayout->getElementTypeLayout();
+      for(auto i = 0; i < this->length; i++) {
+        auto member = std::make_shared<ShaderStructure>(
+          elementType,
+          std::to_string(i),
+          this->start + (i * elementType->getSize())
+        );
+        this->members.push_back(member);
+      }
       break;
     }
 
@@ -54,6 +69,30 @@ ShaderStructure::ShaderStructure(VariableLayoutReflection *reflection) {
   }
 }
 
+std::shared_ptr<ShaderStructure> ShaderStructure::getStructMember(
+  const std::string &name
+) {
+  assertTrue(
+    this->type == ShaderStructureType::STRUCT,
+    "This structure is not a struct."
+  );
+  for(auto &member : this->members) {
+    if(member->name == name) return member;
+  }
+  assertUnreachable("Struct member not found: %s", name.c_str());
+  return nullptr;
+}
+
+std::shared_ptr<ShaderStructure> ShaderStructure::getArrayMember(
+  size_t index
+) {
+  assertTrue(
+    this->type == ShaderStructureType::ARRAY,
+    "This structure is not an array."
+  );
+  return this->members.at(index);
+}
+
 std::shared_ptr<ShaderData> ShaderStructure::createData() {
   return std::make_shared<ShaderData>(shared_from_this());
 }

src/dawn/display/shader/ShaderStructure.hpp

@@ -29,12 +29,12 @@ namespace Dawn {
       ShaderStructureType type;
 
       // Shared properties
-      size_t start = 0;
+      size_t start;
       size_t alignment;
       size_t size;
 
       // Struct properties
-      std::vector<struct ShaderStructure> members;
+      std::vector<std::shared_ptr<struct ShaderStructure>> members;
 
       // Array properties
       size_t length;
@@ -43,8 +43,29 @@ namespace Dawn {
        * Constructs the ShaderStructure object
        * 
        * @param reflection Reflection data to construct the structure from.
+       * @param start Offset to start at.
        */
-      ShaderStructure(VariableLayoutReflection *reflection);
+      ShaderStructure(
+        TypeLayoutReflection *typeLayout,
+        const std::string name,
+        const size_t start
+      );
+
+      /**
+       * Gets a member of this structure by name.
+       * 
+       * @param name Name of the member to get.
+       * @return The member structure.
+       */
+      std::shared_ptr<ShaderStructure> getStructMember(const std::string &name);
+
+      /**
+       * Gets a member of this array structure by index.
+       * 
+       * @param index Index of the member to get.
+       * @return The member structure.
+       */
+      std::shared_ptr<ShaderStructure> getArrayMember(size_t index);
 
       /**
        * Creates data for a shader that matches this structure.

src/dawnopengl/display/shader/ShaderData.cpp

@@ -4,6 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #include "display/shader/ShaderData.hpp"
+#include "assert/assertgl.hpp"
 
 using namespace Dawn;
 
@@ -11,11 +12,31 @@ ShaderData::ShaderData(
   const std::shared_ptr<ShaderStructure> &structure
 ) : IShaderData(structure) {
   glGenBuffers(1, &this->buffer);
+  assertNoGLError();
+}
+
+void ShaderData::upload() {
+  if(!this->dirty) return;
+
+  glBindBuffer(GL_UNIFORM_BUFFER, this->buffer);
+  assertNoGLError();
+  glBindBufferBase(GL_UNIFORM_BUFFER, 0, this->buffer);
+  assertNoGLError();
+  glBufferData(GL_UNIFORM_BUFFER, this->structure->size, this->data, GL_STATIC_DRAW);
+  assertNoGLError();
+  
+  this->dirty = false;
+}
+
+void ShaderData::bind(const GLuint index) {
+  glBindBufferBase(GL_UNIFORM_BUFFER, index, this->buffer);
+  assertNoGLError();
 }
 
 ShaderData::~ShaderData() {
   if(this->buffer != -1) {
     glDeleteBuffers(1, &this->buffer);
+    assertNoGLError();
     this->buffer = -1;
   }
 }

src/dawnopengl/display/shader/ShaderData.hpp

@@ -16,7 +16,8 @@ namespace Dawn {
       ShaderData(
         const std::shared_ptr<ShaderStructure> &structure
       );
-
+      void upload();
+      void bind(const GLuint index);
       ~ShaderData() override;
   };
 }

src/dawnopengl/display/shader/ShaderProgram.cpp

@@ -6,7 +6,7 @@
 #include "ShaderProgram.hpp"
 #include "assert/assert.hpp"
 #include "assert/assertgl.hpp"
-
+#include "display/shader/ShaderData.hpp"
 #include "component/display/material/SimpleTexturedMaterial.hpp"
 
 using namespace Dawn;
@@ -59,78 +59,69 @@ void ShaderProgram::init(
   }
 
   // So the uniforms that are in slang are kinda odd when compiled.
-
-  //DEBUGGING
-  // GLint numUniforms = 0;
-  // 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;
-  // }
-  // auto data = std::make_shared<SimpleTexturedMaterialShaderData>();
-  // data->color = COLOR_WHITE;
-  // data->model = glm::mat4(1.0f);
-  // data->projection = glm::perspective(
-  //   glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 100.0f
-  // );
-  // data->view = glm::lookAt(
-  //   glm::vec3(4,3,3), glm::vec3(0,0,0), glm::vec3(0,1,0)
-  // );
-
   glUseProgram(this->id);
   assertNoGLError();
-  GLuint ubo;
-  glGenBuffers(1, &ubo);
-  assertNoGLError();
 
-  struct TestData data;
+  data = this->structure->createData();
-  data.color = COLOR_WHITE;
+
-  data.model = glm::mat4(1.0f);
+  size_t offset = 0;
-  data.projection = glm::perspective(
+  data->set<glm::mat4>(offset, glm::perspective(
     glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 10000.0f
-  );
+  ));
-  data.view = glm::lookAt(
+  offset += sizeof(glm::mat4);
+
+  data->set<glm::mat4>(offset, glm::lookAt(
     glm::vec3(300,300,300), glm::vec3(0,0,0), glm::vec3(0,1,0)
-  );
+  ));
-  data.hasTexture = false;
+  offset += sizeof(glm::mat4);
-  data.test = 1;
 
-  glBindBuffer(GL_UNIFORM_BUFFER, ubo);
+  data->set<glm::mat4>(offset, glm::mat4(1.0f));
-  assertNoGLError();
+  offset += sizeof(glm::mat4);
-  glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo);
-  assertNoGLError();
-  glBufferData(GL_UNIFORM_BUFFER, sizeof(struct TestData), &data, GL_STATIC_DRAW);
-  assertNoGLError();
 
-  // testTexture = std::make_shared<Texture>();
+  data->set<struct Color>(offset, COLOR_WHITE);
-  // testTexture->setSize(2, 2, TextureFormat::RGBA, TextureDataFormat::UNSIGNED_BYTE);
+  offset += sizeof(glm::vec4);
-  // uint8_t colors[4 * 4];
-  // colors[0] = 255; colors[1] = 0; colors[2] = 0; colors[3] = 255;
-  // colors[4] = 0; colors[5] = 255; colors[6] = 0; colors[7] = 255;
-  // colors[8] = 0; colors[9] = 0; colors[10] = 255; colors[11] = 255;
-  // colors[12] = 255; colors[13] = 255; colors[14] = 255; colors[15] = 255;
-  // testTexture->buffer(colors);
-  // testTexture->bind(0);
 
-  // int index = glGetUniformLocation(this->id, "globalParams_uniforms_texture_0");
+  data->set<bool_t>(offset, true);
+  offset += sizeof(bool_t);
+
+  data->upload();
+  data->bind(0);
+
+
+  // struct TestData data;
+  // data.color = COLOR_WHITE;
+  // data.model = glm::mat4(1.0f);
+  // data.projection = glm::perspective(
+  //   glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 10000.0f
+  // );
+  // data.view = glm::lookAt(
+  //   glm::vec3(300,300,300), glm::vec3(0,0,0), glm::vec3(0,1,0)
+  // );
+  // data.hasTexture = false;
+  // data.test = 1;
+
+  // glBindBuffer(GL_UNIFORM_BUFFER, ubo);
   // assertNoGLError();
-  // std::cout << "Index: " << index << std::endl;
+  // glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo);
-  // glUniform1i(index, 0);
+  // assertNoGLError();
-  // assertNoGLError();  
+  // glBufferData(GL_UNIFORM_BUFFER, sizeof(struct TestData), &data, GL_STATIC_DRAW);
+  // assertNoGLError();
+
+  testTexture = std::make_shared<Texture>();
+  testTexture->setSize(2, 2, TextureFormat::RGBA, TextureDataFormat::UNSIGNED_BYTE);
+  uint8_t colors[4 * 4];
+  colors[0] = 255; colors[1] = 255; colors[2] = 0; colors[3] = 255;
+  colors[4] = 0; colors[5] = 255; colors[6] = 0; colors[7] = 255;
+  colors[8] = 0; colors[9] = 0; colors[10] = 255; colors[11] = 255;
+  colors[12] = 255; colors[13] = 255; colors[14] = 255; colors[15] = 255;
+  testTexture->buffer(colors);
+  testTexture->bind(0);
+
+  int index = glGetUniformLocation(this->id, "globalParams_uniforms_texture_0");
+  assertNoGLError();
+  std::cout << "Index: " << index << std::endl;
+  glUniform1i(index, 0);
+  assertNoGLError();
 
   // data->write(shared_from_this());
 }

src/dawnopengl/display/shader/ShaderProgram.hpp

@@ -12,12 +12,15 @@
 using namespace slang;
 
 namespace Dawn {
+  class ShaderData;
+  
   class ShaderProgram :
     public IShaderProgram,
     public std::enable_shared_from_this<ShaderProgram>
   {
     private:
       GLuint id = -1;
+      std::shared_ptr<ShaderData> data;
       std::shared_ptr<Texture> testTexture;
 
     public: