Got Shaders Reflecting at a very basic level

.gitmodules

@@ -22,4 +22,4 @@
 
 [submodule "Arcane/vendor/SPIRV-Reflect"]
 	path = Arcane/vendor/SPIRV-Reflect
-	url = https://github.com/tomheeleynz/SPIRV-Reflect.git
+	url = https://github.com/KhronosGroup/SPIRV-Reflect.git

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

@@ -1,9 +1,19 @@
 #include "VulkanMaterial.h"
-#include "VulkanShader.h"
 
 namespace Arcane
 {
 	VulkanMaterial::VulkanMaterial(Shader* shader)
 	{
+		m_Shader = shader;
+
+		// Reflect Shader to get descriptor info
+		VulkanShader* vulkanShader = static_cast<VulkanShader*>(shader);
+		vulkanShader->Reflect();
+	}
+
+	std::vector<ShaderVariable> VulkanMaterial::GetShaderVariables()
+	{
+		VulkanShader* vulkanShader = static_cast<VulkanShader*>(m_Shader);
+		return m_Shader->GetShaderVariables();
 	}
 }

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

@@ -1,13 +1,16 @@
 #pragma once
 
 #include "Arcane/Renderer/Material.h"
+#include "VulkanShader.h"
 
 namespace Arcane
 {
-	class VulkanMaterial: public Material
+	class VulkanMaterial : public Material
 	{
 	public:
 		VulkanMaterial(Shader* shader);
+
+		std::vector<ShaderVariable> GetShaderVariables();
 	private:
 		Shader* m_Shader;
 	};

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

@@ -72,60 +72,65 @@ namespace Arcane {
 
 	void VulkanShader::Reflect() 
 	{
-		// Reflect Vertex Module
+		// Reflect Fragment Module
 		{
 			SpvReflectShaderModule module;
 
 			SpvReflectResult result = spvReflectCreateShaderModule(
-				m_VertexByteCode.size(),
-				m_VertexByteCode.data(),
+				m_FragmentByteCode.size(),
+				m_FragmentByteCode.data(),
 				&module
 			);
 
 			if (result != SPV_REFLECT_RESULT_SUCCESS) {
-				printf("Vertex Reflect Module not created\n");
+				printf("Failed to Create Reflect Module\n");
 			}
 
-			uint32_t bindingCount = 0;
-			std::vector<SpvReflectDescriptorBinding*> bindings;
-			result = spvReflectEnumerateDescriptorBindings(&module, &bindingCount, NULL);
+			uint32_t count = 0;
+			result = spvReflectEnumerateDescriptorSets(&module, &count, nullptr);
 
 			if (result != SPV_REFLECT_RESULT_SUCCESS) {
-				printf("No Binding Descriptors found\n");
+				printf("Failed to enum descriptor sets\n");
 			}
 
-			bindings.resize(bindingCount);
-			result = spvReflectEnumerateDescriptorBindings(&module, &bindingCount, bindings.data());
-
+			std::vector<SpvReflectDescriptorSet*> sets(count);
+			result = spvReflectEnumerateDescriptorSets(&module, &count, sets.data());
+			
 			if (result != SPV_REFLECT_RESULT_SUCCESS) {
-				printf("Bindings Not Retreived\n");
+				printf("Failed to load reflect descriptor sets\n");
 			}
 
-		}
-
-		// Reflect Fragment Module
-		{
-			SpvReflectShaderModule module;
-
-			SpvReflectResult result = spvReflectCreateShaderModule(
-				m_VertexByteCode.size(),
-				m_VertexByteCode.data(),
-				&module
-			);
-
-			if (result != SPV_REFLECT_RESULT_SUCCESS) {
-				printf("Vertex Reflect Module not created\n");
+			// Get the material set, which will be set 2 binding 0
+			for (int i = 0; i < sets.size(); i++) 
+			{
+				SpvReflectDescriptorSet* reflectSet = sets[i];
+
+
+				// Get into the bindings,
+				// Material will be binding 0
+				for (int j = 0; j < reflectSet->binding_count; j++) {
+					SpvReflectDescriptorBinding* binding = reflectSet->bindings[j];
+
+					if (binding->binding == 0) {
+						// Get stuff in the material block
+						SpvReflectTypeDescription* description = binding->type_description;
+
+						for (int k = 0; k < description->member_count; k++) {
+							SpvReflectTypeDescription memberDesc = description->members[k];
+							ShaderVariable newVariable;
+							newVariable.Name = memberDesc.struct_member_name;
+
+							if (memberDesc.traits.numeric.vector.component_count == 3) {
+								newVariable.Type = ShaderVariableType::Vector3;
+							}
+
+							m_ShaderVariables.push_back(newVariable);
+						}
+					}
+				}
 			}
 
-			uint32_t descriptorCount = 0;
-			result = spvReflectEnumerateDescriptorSets(&module, &descriptorCount, nullptr);
 
-			if (result != SPV_REFLECT_RESULT_SUCCESS) {
-				printf("Cant Reflect Descriptor Sets\n");
-			}
-			else {
-				printf("Descriptor Sets %d\n", descriptorCount);
-			}
 		}
 	}
 }

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

@@ -12,6 +12,7 @@ namespace Arcane {
 	{
 	public:
 		VulkanShader(std::string vertexShader, std::string fragmentShader);
+		virtual std::vector<ShaderVariable> GetShaderVariables() { return m_ShaderVariables; };
 
 		VkShaderModule GetVertexShaderModule() { return m_VertexShaderModule; }
 		VkShaderModule GetFragmentShaderModule() { return m_FragShaderModule; }
@@ -22,5 +23,7 @@ namespace Arcane {
 
 		std::vector<char> m_VertexByteCode;
 		std::vector<char> m_FragmentByteCode;
+
+		std::vector<ShaderVariable> m_ShaderVariables;
 	};
 }

Arcane/src/Arcane/Renderer/Material.cpp

@@ -1,6 +1,5 @@
 #include "Material.h"
 #include "Renderer.h"
-
 #include "Arcane/Platform/Vulkan/VulkanMaterial.h"
 
 namespace Arcane

Arcane/src/Arcane/Renderer/Material.h

@@ -7,6 +7,7 @@ namespace Arcane
 	class Material
 	{
 	public:
+		virtual std::vector<ShaderVariable> GetShaderVariables() = 0;
 		static Material* Create(Shader* shader);
 	private:
 	};

Arcane/src/Arcane/Renderer/Shader.h

@@ -2,16 +2,30 @@
 
 #include <string>
 #include <map>
+#include <vector>
 
 namespace Arcane 
 {
+	enum class ShaderVariableType
+	{
+		Vector3,
+		Sampler
+	};
+
+	struct ShaderVariable
+	{
+		std::string Name;
+		ShaderVariableType Type;
+	};
+
 	/////////////////////////////////////////////////////////////
 	//// Shader
 	/////////////////////////////////////////////////////////////
 	class Shader
 	{
 	public:
 
+		virtual std::vector<ShaderVariable> GetShaderVariables() = 0;
 		static Shader* Create(std::string vertexShader, std::string fragmentShader);
 	private:
 

EnchantingTable/src/Assets/Shaders/Mesh.frag

@@ -7,7 +7,7 @@ layout(location = 2) in vec3 fragCameraPos;
 layout(location = 0) out vec4 Color;
 
 // Material Structure
-layout (set = 2, binding = 0) Material {
+layout (set = 2, binding = 0) uniform Material {
 	vec3 color;
 } material;
 

EnchantingTable/src/Panels/EntityPanel.cpp

@@ -69,7 +69,17 @@ void EntityPanel::DrawComponents(Arcane::Entity& entity)
 	if (entity.HasComponent<MeshRendererComponent>())
 	{
 		DrawComponent<MeshRendererComponent>("Mesh Renderer", entity, [](auto& component) {
+			std::vector<Arcane::ShaderVariable> shaderVariables = component.material->GetShaderVariables();
 
+			for (Arcane::ShaderVariable variable : shaderVariables)
+			{
+				ImGui::Text(variable.Name.c_str());
+
+				glm::vec3 color = glm::vec3(0.0f, 0.0f, 0.0f);
+				if (variable.Type == Arcane::ShaderVariableType::Vector3){
+					ImGui::InputFloat3("Vec3", glm::value_ptr(color));
+				}
+			}
 		});
 	}
 }