Got Material Variables updating

Arcane/src/Arcane/Platform/Vulkan/VulkanMaterial.cpp

@@ -10,13 +10,32 @@ namespace Arcane
 		VulkanShader* vulkanShader = static_cast<VulkanShader*>(shader);
 
 		// Get Material descriptor, then add uniform buffer to it
+		m_UniformBuffer = UniformBuffer::Create(vulkanShader->GetMaterialSize());
 
+		// Create internal structure
+		m_UniformBufferMemory = new float[vulkanShader->GetMaterialSize()];
 	}
 
-	std::vector<ShaderVariable> VulkanMaterial::GetShaderVariables()
+	void VulkanMaterial::WriteVec3(uint32_t offset, glm::vec3 value)
+	{
+		m_UniformBufferMemory[offset] = value.x;
+		m_UniformBufferMemory[offset + 1] = value.y;
+		m_UniformBufferMemory[offset + 2] = value.z;
+	}
+
+	glm::vec3 VulkanMaterial::GetVec3(uint32_t offset)
+	{
+		return glm::vec3(
+			m_UniformBufferMemory[offset], 
+			m_UniformBufferMemory[offset + 1], 
+			m_UniformBufferMemory[offset + 2]
+		);
+	}
+
+	std::vector<ShaderVariable> VulkanMaterial::GetMaterialVariables()
 	{
 		VulkanShader* vulkanShader = static_cast<VulkanShader*>(m_Shader);
-		return m_Shader->GetShaderVariables();
+		return m_Shader->GetMaterialVariables();
 	}
 
 	DescriptorSet* VulkanMaterial::GetDescriptorSet()
@@ -28,4 +47,5 @@ namespace Arcane
 	{
 		return m_UniformBuffer;
 	}
+
 }

Arcane/src/Arcane/Platform/Vulkan/VulkanMaterial.h

@@ -13,10 +13,17 @@ namespace Arcane
 		DescriptorSet* GetDescriptorSet() override;
 		UniformBuffer* GetUniformBuffer() override;
 
-		std::vector<ShaderVariable> GetShaderVariables();
+		// Get Material Variables from material buffer
+		virtual glm::vec3 GetVec3(uint32_t offset) override;
+
+		// Write Material Variables to material buffer
+		virtual void WriteVec3(uint32_t offset, glm::vec3 value) override;
+
+		std::vector<ShaderVariable> GetMaterialVariables();
 	private:
 		Shader* m_Shader;
 		DescriptorSet* m_DescriptorSet;
 		UniformBuffer* m_UniformBuffer;
+		float* m_UniformBufferMemory;
 	};
 }

Arcane/src/Arcane/Platform/Vulkan/VulkanShader.cpp

@@ -132,6 +132,8 @@ namespace Arcane {
 				printf("Failed to load reflect descriptor sets\n");
 			}
 
+			uint32_t offset = 0;
+			uint32_t size = 0;
 			for (int i = 0; i < sets.size(); i++) {
 				SpvReflectDescriptorSet* reflectSet = sets[i];
 				// DescriptorSetLayoutData newData;
@@ -143,22 +145,49 @@ namespace Arcane {
 
 					std::vector<DescriptorLayoutSpecs> bindings;
 					bindings.resize(reflectSet->binding_count);
-
 					for (int j = 0; j < reflectSet->binding_count; j++) {
 						// Get the reflected binding
 						const SpvReflectDescriptorBinding& reflBinding = *(reflectSet->bindings[j]);
+						ShaderVariable newVariable;
+
+						for (int k = 0; k < reflBinding.type_description->member_count; k++)
+						{
+							// This gets the member variable
+							SpvReflectTypeDescription& memberDesc = reflBinding.type_description->members[k];
+
+							if (memberDesc.traits.numeric.vector.component_count == 3)
+							{
+								// This is a vector 3
+								newVariable.Type = ShaderVariableType::Vec3;
+								newVariable.offset = offset;
+								newVariable.size = sizeof(float) * 3;
+								newVariable.Name = memberDesc.struct_member_name;
+
+								m_MaterialVariables.push_back(newVariable);
+
+								size += sizeof(float) * 3;
+								offset += 3;
+							}
+						}
 
+						// Get the actual material variables
 						if (reflBinding.binding == 0)
 						{
 							// Create my struct for a binding
 							DescriptorLayoutSpecs& binding = bindings[j];
+
+							// Binding number
 							binding.Binding = reflBinding.binding;
+
 							// location
 							binding.Location = DescriptorLocation::FRAGMENT;
+
 							// descriptor count
 							binding.DescriptorCount = 1;
+
 							// material
 							binding.Name = "Material";
+
 							// Uniform Buffer
 							binding.Type = DescriptorType::UNIFORM_BUFFER;
 						}
@@ -167,6 +196,7 @@ namespace Arcane {
 					m_MaterialSet = DescriptorSet::Create(newSetSpecs, bindings);
 				}
 			}
+			m_MaterialSize = size;
 		}
 	}
 }

Arcane/src/Arcane/Platform/Vulkan/VulkanShader.h

@@ -9,12 +9,13 @@
 
 namespace Arcane 
 {
-
 	class VulkanShader : public Shader
 	{
 	public:
 		VulkanShader(std::string vertexShader, std::string fragmentShader);
-		virtual std::vector<ShaderVariable> GetShaderVariables() { return m_ShaderVariables; };
+
+		virtual std::vector<ShaderVariable> GetMaterialVariables() { return m_MaterialVariables; };
+		virtual uint32_t GetMaterialSize() { return m_MaterialSize; }
 
 		VkShaderModule GetVertexShaderModule() { return m_VertexShaderModule; }
 		VkShaderModule GetFragmentShaderModule() { return m_FragShaderModule; }
@@ -28,10 +29,11 @@ namespace Arcane
 		VkShaderModule m_FragShaderModule;
 
 		DescriptorSet* m_MaterialSet = nullptr;
+		uint32_t m_MaterialSize = 0;
 
 		std::vector<char> m_VertexByteCode;
 		std::vector<char> m_FragmentByteCode;
 
-		std::vector<ShaderVariable> m_ShaderVariables;
+		std::vector<ShaderVariable> m_MaterialVariables;
 	};
 }

Arcane/src/Arcane/Renderer/Material.h

@@ -1,5 +1,5 @@
 #pragma once
-
+#include <glm/glm.hpp>
 #include "Shader.h"
 #include "DescriptorSet.h"
 #include "UniformBuffer.h"
@@ -9,10 +9,15 @@ namespace Arcane
 	class Material
 	{
 	public:
-		virtual std::vector<ShaderVariable> GetShaderVariables() = 0;
+		virtual std::vector<ShaderVariable> GetMaterialVariables() = 0;
 		virtual DescriptorSet* GetDescriptorSet() = 0;
 		virtual UniformBuffer* GetUniformBuffer() = 0;
+
+		// Get Material Variables from material buffer
+		virtual glm::vec3 GetVec3(uint32_t offset) = 0;
 
+		// Write Material Variables to material buffer
+		virtual void WriteVec3(uint32_t offset, glm::vec3 value) = 0;
 
 		static Material* Create(Shader* shader);
 	private:

Arcane/src/Arcane/Renderer/Shader.h

@@ -9,14 +9,18 @@ namespace Arcane
 {
 	enum class ShaderVariableType
 	{
-		Vector3,
-		Sampler
+		Float,
+		Vec3,
+		Vec2,
+		Int
 	};
 
 	struct ShaderVariable
 	{
 		std::string Name;
 		ShaderVariableType Type;
+		uint32_t size;
+		uint32_t offset;
 	};
 
 	/////////////////////////////////////////////////////////////
@@ -26,7 +30,8 @@ namespace Arcane
 	{
 	public:
 		virtual DescriptorSet* GetMaterialDescriptor() = 0;
-		virtual std::vector<ShaderVariable> GetShaderVariables() = 0;
+		virtual std::vector<ShaderVariable> GetMaterialVariables() = 0;
+		virtual uint32_t GetMaterialSize() = 0;
 		static Shader* Create(std::string vertexShader, std::string fragmentShader);
 	private:
 

EnchantingTable/src/Panels/EntityPanel.cpp

@@ -62,22 +62,23 @@ void EntityPanel::DrawComponents(Arcane::Entity& entity)
 	if (entity.HasComponent<MeshComponent>()) 
 	{
 		DrawComponent<MeshComponent>("Mesh", entity, [](auto& component) {
-
 		});
 	}
 
 	if (entity.HasComponent<MeshRendererComponent>())
 	{
 		DrawComponent<MeshRendererComponent>("Mesh Renderer", entity, [](auto& component) {
-			std::vector<Arcane::ShaderVariable> shaderVariables = component.material->GetShaderVariables();
-
-			for (Arcane::ShaderVariable variable : shaderVariables)
+			Material* material = component.material;
+			for (Arcane::ShaderVariable variable : material->GetMaterialVariables())
 			{
-				ImGui::Text(variable.Name.c_str());
+				if (variable.Type == Arcane::ShaderVariableType::Vec3)
+				{
+					glm::vec3 currentValue = material->GetVec3(variable.offset);
+					if (currentValue.x < 0)
+						currentValue = {0.0f, 0.0f, 0.0f};
 
-				glm::vec3 color = glm::vec3(0.0f, 0.0f, 0.0f);
-				if (variable.Type == Arcane::ShaderVariableType::Vector3){
-					ImGui::InputFloat3("Vec3", glm::value_ptr(color));
+					ImGui::ColorEdit3(variable.Name.c_str(), glm::value_ptr(currentValue));
+					material->WriteVec3(variable.offset, currentValue);
 				}
 			}
 		});