Reflection 더 자세히 출력.

TestApp1/TestApp1.cpp

 #endif
 #include <DK.h>
 
+DKString ShaderStageNames(uint32_t s)
+{
+	DKArray<const char*> stages;
+	if (s & (uint32_t)DKShaderStage::Vertex)
+		stages.Add("Vertex");
+	if (s & (uint32_t)DKShaderStage::TessellationControl)
+		stages.Add("TessCtrl");
+	if (s & (uint32_t)DKShaderStage::TessellationEvaluation)
+		stages.Add("TessEval");
+	if (s & (uint32_t)DKShaderStage::Geometry)
+		stages.Add("Geometry");
+	if (s & (uint32_t)DKShaderStage::Fragment)
+		stages.Add("Fragment");
+	if (s & (uint32_t)DKShaderStage::Compute)
+		stages.Add("Compute");
+
+	if (stages.IsEmpty())
+		return "";
+
+	DKString str = stages.Value(0);
+	for (int i = 1; i < stages.Count(); ++i)
+		str += DKString::Format(", %ls", stages.Value(i));
+	return str;
+}
+
 const char* ShaderDataTypeStr(DKShaderDataType t)
 {
 	switch (t) {
 	return "Error";
 }
 
-DKVertexDescriptor VertexDescriptorForVertexAttributes(const DKArray<DKVertexAttribute>& attrs)
+DKVertexDescriptor VertexDescriptorForVertexAttributes(const DKArray<DKShaderAttribute>& attrs)
 {
     uint32_t vertexSize = 0;
     DKVertexDescriptor descriptor = {};
 
     for (uint32_t i = 0; i < attrs.Count(); ++i)
     {         
-        if (const DKVertexAttribute& attr = attrs.Value(i); attr.active)
+        if (const DKShaderAttribute& attr = attrs.Value(i); attr.enabled)
         {
             DKVertexAttributeDescriptor desc = {};
 
 			}
 		}
 	};
+
+
 	if (res.count > 1)
-		DKLog(c, "ShaderResource: %ls[%d] (set=%d, binding=%d)",
-		(const wchar_t*)res.name, res.count, res.set, res.binding);
+		DKLog(c, "ShaderResource: %ls[%d] (set=%d, binding=%d, stages=%ls)",
+			 (const wchar_t*)res.name, res.count, res.set, res.binding,
+			 (const wchar_t*)ShaderStageNames(res.stages));
 	else
-		DKLog(c, "ShaderResource: %ls (set=%d, binding=%d)", (const wchar_t*)res.name, res.set, res.binding);
+		DKLog(c, "ShaderResource: %ls (set=%d, binding=%d, stages=%ls)",
+			 (const wchar_t*)res.name, res.set, res.binding,
+			 (const wchar_t*)ShaderStageNames(res.stages));
 
 	const char* type = "Unknown (ERROR)";
 	switch (res.type)
 
     DKObject<DKGraphicsDevice> device;
 
-    void PrintShaderAttributes(const DKArray<DKShaderAttribute>& attrs, const char* prefix, DKLogCategory c = DKLogCategory::Warning)
-    {
-        for (int i = 0; i < attrs.Count(); ++i)
-        {
-            const DKShaderAttribute& attr = attrs.Value(i);
-            DKLog(c, "  %s ShaderAttribute[%d]: \"%ls\" (location:%u)",
-                  prefix,
-                  i, (const wchar_t*)attr.name, attr.location);
-        }
-    }
-    void PrintPushConstantLayouts(const DKArray<DKShader::PushConstantLayout>& layouts, DKLogCategory c = DKLogCategory::Warning)
-    {
-        for (int i = 0; i < layouts.Count(); ++i)
-        {
-            const DKShader::PushConstantLayout& layout = layouts.Value(i);
-            DKLog(c, " PushConstant:%d \"%ls\" (Offset:%u, Size:%u)",
-                  i,
-                  (const wchar_t*)layout.name, layout.offset, layout.size);
+	void PrintShaderReflection(const DKShader* shader, DKLogCategory c = DKLogCategory::Warning)
+	{
+		DKString stage = ShaderStageNames((uint32_t)shader->Stage());
+		if (stage.Length() == 0)
+			stage = "Unknown";
+
+		DKLog(c, "=========================================================");
+		DKLog(c, "Shader<%ls.SPIR-V>.InputAttributes: %d",
+			(const wchar_t*)stage, shader->InputAttributes().Count());
+		for (int i = 0; i < shader->InputAttributes().Count(); ++i)
+		{
+			const DKShaderAttribute& attr = shader->InputAttributes().Value(i);
+			DKLog(c, "  [in] ShaderAttribute[%d]: \"%ls\" (location:%u)",
+				  i, (const wchar_t*)attr.name, attr.location);
+		}
+		DKLog(c, "---------------------------------------------------------");
+		DKLog(c, "Shader<%ls.SPIR-V>.OutputAttributes: %d",
+			(const wchar_t*)stage, shader->OutputAttributes().Count());
+		for (int i = 0; i < shader->OutputAttributes().Count(); ++i)
+		{
+			const DKShaderAttribute& attr = shader->OutputAttributes().Value(i);
+			DKLog(c, "  [out] ShaderAttribute[%d]: \"%ls\" (location:%u)",
+				  i, (const wchar_t*)attr.name, attr.location);
+		}
+		DKLog(c, "---------------------------------------------------------");
+		DKLog(c, "Shader<%ls.SPIR-V>.Resources: %d",
+			  (const wchar_t*)stage, shader->Resources().Count());
+		for (auto& arg : shader->Resources())
+			PrintShaderResource(arg, c);
+		for (int i = 0; i < shader->PushConstantBufferLayouts().Count(); ++i)
+		{
+			const DKShaderPushConstantLayout& layout = shader->PushConstantBufferLayouts().Value(i);
+			DKLog(c, " PushConstant:%d \"%ls\" (offset:%u, size:%u, stages:%ls)",
+				  i, (const wchar_t*)layout.name, layout.offset, layout.size,
+				  (const wchar_t*)ShaderStageNames(layout.stages));
+		}
+		DKLog(c, "=========================================================");
+	}
 
-        }
-    }
+	void PrintPipelineReflection(const DKPipelineReflection* reflection, DKLogCategory c = DKLogCategory::Error)
+	{
+		DKLog(c, "=========================================================");
+		DKLog(c, "PipelineReflection.InputAttributes: %d", reflection->inputAttributes.Count());
+		for (int i = 0; i < reflection->inputAttributes.Count(); ++i)
+		{
+			const DKShaderAttribute& attr = reflection->inputAttributes.Value(i);
+			DKLog(c, "  [in] ShaderAttribute[%d]: \"%ls\" (location:%u)",
+				  i, (const wchar_t*)attr.name, attr.location);
+		}
+		DKLog(c, "---------------------------------------------------------");
+		DKLog(c, "PipelineReflection.Resources: %d", reflection->resources.Count());
+		for (auto& arg : reflection->resources)
+			PrintShaderResource(arg, c);
+		for (int i = 0; i < reflection->pushConstantLayouts.Count(); ++i)
+		{
+			const DKShaderPushConstantLayout& layout = reflection->pushConstantLayouts.Value(i);
+			DKLog(c, " PushConstant:%d \"%ls\" (offset:%u, size:%u, stages:%ls)",
+				  i, (const wchar_t*)layout.name, layout.offset, layout.size,
+				  (const wchar_t*)ShaderStageNames(layout.stages));
+		}
+		DKLog(c, "=========================================================");
+	}
 
     void TestRenderPipelineReflection(const DKString& path)
     {
         DKShader vertShader(vertData);
         DKShader fragShader(fragData);
 
-        if (1)
-        {
-            DKLogCategory c = DKLogCategory::Warning;
-            DKLog(c, "=========================================================");
-            DKLog(c, "Vertex-Shader<SPIR-V>.InputAttributes: %d", vertShader.InputAttributes().Count());
-            PrintShaderAttributes(vertShader.InputAttributes(), "[IN] ", c);
-            DKLog(c, "---------------------------------------------------------");
-            DKLog(c, "Vertex-Shader<SPIR-V>.OutputAttributes: %d", vertShader.OutputAttributes().Count());
-            PrintShaderAttributes(vertShader.OutputAttributes(), "[OUT]", c);
-            DKLog(c, "---------------------------------------------------------");
-            DKLog(c, "Fragment-Shader<SPIR-V>.InputAttributes: %d", fragShader.InputAttributes().Count());
-            PrintShaderAttributes(fragShader.InputAttributes(), "[IN] ", c);
-            DKLog(c, "---------------------------------------------------------");
-            DKLog(c, "Fragment-Shader<SPIR-V>.OutputAttributes: %d", fragShader.OutputAttributes().Count());
-            PrintShaderAttributes(fragShader.OutputAttributes(), "[OUT]", c);
-            DKLog(c, "---------------------------------------------------------");
-            DKLog(c, "Vertex-Shader<SPIR-V>.Resources: %d", vertShader.Resources().Count());
-            for (auto& arg : vertShader.Resources())
-                PrintShaderResource(arg, c);
-            PrintPushConstantLayouts(vertShader.PushConstantBufferLayouts());
-            DKLog(c, "---------------------------------------------------------");
-            DKLog(c, "Fragment-Shader<SPIR-V>.Resources: %d", fragShader.Resources().Count());
-            for (auto& arg : fragShader.Resources())
-                PrintShaderResource(arg, c);
-            PrintPushConstantLayouts(fragShader.PushConstantBufferLayouts());
-            DKLog(c, "=========================================================");
-        }
+		PrintShaderReflection(&vertShader, DKLogCategory::Warning);
+		PrintShaderReflection(&fragShader, DKLogCategory::Warning);
 
         DKObject<DKShaderModule> vertShaderModule = device->CreateShaderModule(&vertShader);
         DKObject<DKShaderModule> fragShaderModule = device->CreateShaderModule(&fragShader);
         pipelineDescriptor.cullMode = DKCullMode::None;
         pipelineDescriptor.rasterizationEnabled = true;
 
-        DKRenderPipelineReflection reflection;
+        DKPipelineReflection reflection;
         DKObject<DKRenderPipelineState> pipelineState = device->CreateRenderPipeline(pipelineDescriptor, &reflection);
         if (pipelineState)
         {
-            DKLogCategory c = DKLogCategory::Error;
-            DKLog(c, "=========================================================");
-            DKLog(c, "VertexFunction.StageInputAttributes: %d", vertShaderFunction->StageInputAttributes().Count());
-            PrintShaderAttributes(vertShaderFunction->StageInputAttributes(), "[IN] ", c);
-            DKLog(c, "---------------------------------------------------------");
-            DKLog(c, "FragmentFunction.StageInputAttributes: %d", fragShaderFunction->StageInputAttributes().Count());
-            PrintShaderAttributes(fragShaderFunction->StageInputAttributes(), "[IN] ", c);
-            DKLog(c, "---------------------------------------------------------");
-            DKLog(c, "PipelineReflection.VertexResources: %d", reflection.vertexResources.Count());
-            for (auto& arg : reflection.vertexResources)
-                PrintShaderResource(arg, c);
-            DKLog(c, "---------------------------------------------------------");
-            DKLog(c, "PipelineReflection.FragmentResources: %d", reflection.fragmentResources.Count());
-            for (auto& arg : reflection.fragmentResources)
-                PrintShaderResource(arg, c);
-            DKLog(c, "=========================================================");
+			PrintPipelineReflection(&reflection, DKLogCategory::Error);
         }
         else
         {
 
         DKShader shader(shaderData);
 
-        if (1)
-        {
-            DKLogCategory c = DKLogCategory::Warning;
-            DKLog(c, "=========================================================");
-            DKLog(c, "Compute-Shader<SPIR-V>.InputAttributes: %d", shader.InputAttributes().Count());
-            PrintShaderAttributes(shader.InputAttributes(), "[IN] ", c);
-            DKLog(c, "---------------------------------------------------------");
-            DKLog(c, "Compute-Shader<SPIR-V>.OutputAttributes: %d", shader.OutputAttributes().Count());
-            PrintShaderAttributes(shader.OutputAttributes(), "[OUT]", c);
-            DKLog(c, "---------------------------------------------------------");
-            DKLog(c, "Compute-Shader<SPIR-V>.Resources: %d", shader.Resources().Count());
-            for (auto& arg : shader.Resources())
-                PrintShaderResource(arg, c);
-            PrintPushConstantLayouts(shader.PushConstantBufferLayouts());
-            DKLog(c, "=========================================================");
-        }
+		PrintShaderReflection(&shader, DKLogCategory::Warning);
 
         DKObject<DKShaderModule> shaderModule = device->CreateShaderModule(&shader);
         DKObject<DKShaderFunction> shaderFunction = shaderModule->CreateFunction(shaderModule->FunctionNames().Value(0));
         DKComputePipelineDescriptor pipelineDescriptor = {};
         pipelineDescriptor.computeFunction = shaderFunction;
 
-        DKComputePipelineReflection reflection;
+        DKPipelineReflection reflection;
         DKObject<DKComputePipelineState> pipelineState = device->CreateComputePipeline(pipelineDescriptor, &reflection);
         if (pipelineState)
         {
-            DKLogCategory c = DKLogCategory::Error;
-            DKLog(c, "=========================================================");
-            DKLog(c, "ComputeFunction.StageInputAttributes: %d", shaderFunction->StageInputAttributes().Count());
-            PrintShaderAttributes(shaderFunction->StageInputAttributes(), "[IN]", c);
-            DKLog(c, "---------------------------------------------------------");
-            DKLog(c, "PipelineReflection.Resources: %d", reflection.resources.Count());
-            for (auto& arg : reflection.resources)
-                PrintShaderResource(arg, c);
-            DKLog(c, "=========================================================");
+			PrintPipelineReflection(&reflection, DKLogCategory::Error);
         }
         else
         {