no message

TestApp1/TestApp1.cpp

     return descriptor;
 };
 
-void PrintShaderResource(const DKShaderResource& res)
+void PrintShaderResource(const DKShaderResource& res, DKLogCategory c = DKLogCategory::Info)
 {
 	struct MemberPrinter
 	{
 		const DKShaderResource& res;
 		int indent;
+        DKLogCategory c;
 		void operator()(const DKShaderResourceStruct& str) const
 		{
 			DKString indentStr = "";
 			{
 				if (mem.count > 1)
 				{
-					DKLogI(" %ls+ %ls[%d] (%s, Offset: %d, Stride: %d)",
+					DKLog(c, " %ls+ %ls[%d] (%s, Offset: %d, Stride: %d)",
 						   (const wchar_t*)indentStr,
 						   (const wchar_t*)mem.name,
 						   mem.count,
 				}
 				else
 				{
-					DKLogI(" %ls+ %ls (%s, Offset: %d)",
+					DKLog(c, " %ls+ %ls (%s, Offset: %d)",
 						   (const wchar_t*)indentStr,
 						   (const wchar_t*)mem.name,
 						   ShaderDataTypeStr(mem.dataType),
 				auto* p = res.structTypeMemberMap.Find(mem.typeInfoKey);
 				if (p)
 				{
-					DKLogI(" %ls  Struct \"%ls\"",
+					DKLog(c, " %ls  Struct \"%ls\"",
 						   (const wchar_t*)indentStr,
 						   (const wchar_t*)mem.typeInfoKey);
-					MemberPrinter{ res, indent + 1 }.operator()(p->value);
+					MemberPrinter{ res, indent + 1, c}.operator()(p->value);
 				}
 			}
 		}
 	};
 	if (res.count > 1)
-		DKLogI("ShaderResource: %ls[%d] (set=%d, binding=%d)",
+		DKLog(c, "ShaderResource: %ls[%d] (set=%d, binding=%d)",
 		(const wchar_t*)res.name, res.count, res.set, res.binding);
 	else
-		DKLogI("ShaderResource: %ls (set=%d, binding=%d)", (const wchar_t*)res.name, res.set, res.binding);
+		DKLog(c, "ShaderResource: %ls (set=%d, binding=%d)", (const wchar_t*)res.name, res.set, res.binding);
 
 	const char* type = "Unknown (ERROR)";
 	switch (res.type)
 	case DKShaderResource::TypeTexture:	type = "Texture"; break;
 	case DKShaderResource::TypeSampler:	type = "Sampler"; break;
     case DKShaderResource::TypeSampledTexture: type = "SampledTexture"; break;
-	case DKShaderResource::TypeThreadgroupMemory:	type = "Threadinggroup"; break;
 	}
 	const char* access = "Unknown (ERROR)";
 	switch (res.access)
 
     if (res.type == DKShaderResource::TypeBuffer)
     {
-        DKLogI(" Type:%s, Access:%s, Enabled:%d, Size:%d",
+        DKLog(c, " Type:%s, Access:%s, Enabled:%d, Size:%d",
                type,
                access,
                int(res.enabled),
     }
     else
     {
-        DKLogI(" Type:%s, Access:%s, Enabled:%d",
+        DKLog(c, " Type:%s, Access:%s, Enabled:%d",
                type,
                access,
                int(res.enabled));
     }
 	if (res.typeInfoKey.Length() > 0)
-		DKLogI(" Struct \"%ls\"", (const wchar_t*)res.typeInfoKey);
+		DKLog(c, " Struct \"%ls\"", (const wchar_t*)res.typeInfoKey);
 	if (res.type == DKShaderResource::TypeBuffer)
 	{
 		auto p = res.structTypeMemberMap.Find(res.typeInfoKey);
 		if (p)
-			MemberPrinter{ res, 1 }.operator()(p->value);
+			MemberPrinter{ res, 1 , c}.operator()(p->value);
 	}
 }
 
 
     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 TestRenderPipelineReflection(const DKString& path)
     {
         DKObject<DKData> vertData = resourcePool.LoadResourceData(path + ".vert.spv");
         DKASSERT(vertData);
         DKASSERT(fragData);
 
-        DKShader vertShader(vertData, DKShader::Vertex);
-        DKShader fragShader(fragData, DKShader::Fragment);
+        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, "=========================================================");
+        }
 
         DKObject<DKShaderModule> vertShaderModule = device->CreateShaderModule(&vertShader);
         DKObject<DKShaderModule> fragShaderModule = device->CreateShaderModule(&fragShader);
         DKObject<DKShaderFunction> vertShaderFunction = vertShaderModule->CreateFunction(vertShaderModule->FunctionNames().Value(0));
         DKObject<DKShaderFunction> fragShaderFunction = fragShaderModule->CreateFunction(fragShaderModule->FunctionNames().Value(0));
 
-        DKLog("VertexFunction.VertexAttributes: %d", vertShaderFunction->VertexAttributes().Count());
-        for (int i = 0; i < vertShaderFunction->VertexAttributes().Count(); ++i)
-        {
-            const DKVertexAttribute& attr = vertShaderFunction->VertexAttributes().Value(i);
-            DKLog("  --> VertexAttribute[%d]: \"%ls\" (location:%u)", i, (const wchar_t*)attr.name, attr.location);
-        }
-
         // setup dummy vertex-descriptor
-        DKVertexDescriptor vertexDescriptor = VertexDescriptorForVertexAttributes(vertShaderFunction->VertexAttributes());
+        DKVertexDescriptor vertexDescriptor = VertexDescriptorForVertexAttributes(vertShaderFunction->StageInputAttributes());
 
         // setup rendering pipeline state object (PSO)
         DKRenderPipelineDescriptor pipelineDescriptor = {};
         DKObject<DKRenderPipelineState> pipelineState = device->CreateRenderPipeline(pipelineDescriptor, &reflection);
         if (pipelineState)
         {
-            DKLog("=========================================================");
-            DKLog("PipelineReflection.VertexResources: %d", reflection.vertexResources.Count());
+            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);
-            DKLog("---------------------------------------------------------");
-            DKLog("PipelineReflection.FragmentResources: %d", reflection.fragmentResources.Count());
+                PrintShaderResource(arg, c);
+            DKLog(c, "---------------------------------------------------------");
+            DKLog(c, "PipelineReflection.FragmentResources: %d", reflection.fragmentResources.Count());
             for (auto& arg : reflection.fragmentResources)
-                PrintShaderResource(arg);
-            DKLog("=========================================================");
+                PrintShaderResource(arg, c);
+            DKLog(c, "=========================================================");
         }
         else
         {
 
         DKASSERT(shaderData);
 
-        DKShader shader(shaderData, DKShader::Compute);
+        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, "=========================================================");
+        }
 
         DKObject<DKShaderModule> shaderModule = device->CreateShaderModule(&shader);
         DKObject<DKShaderFunction> shaderFunction = shaderModule->CreateFunction(shaderModule->FunctionNames().Value(0));
 
-        DKLog("ComputeFunction.StageInputAttributes: %d", shaderFunction->StageInputAttributes().Count());
-        for (int i = 0; i < shaderFunction->StageInputAttributes().Count(); ++i)
-        {
-            const DKShaderAttribute& attr = shaderFunction->StageInputAttributes().Value(i);
-            DKLog("  --> ShaderAttribute[%d]: \"%ls\" (location:%u)", i, (const wchar_t*)attr.name, attr.location);
-        }
 
         // setup pipeline state object (PSO)
         DKComputePipelineDescriptor pipelineDescriptor = {};
         DKObject<DKComputePipelineState> pipelineState = device->CreateComputePipeline(pipelineDescriptor, &reflection);
         if (pipelineState)
         {
-            DKLog("=========================================================");
-            DKLog("PipelineReflection.Resources: %d", reflection.resources.Count());
+            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);
-            DKLog("=========================================================");
+                PrintShaderResource(arg, c);
+            DKLog(c, "=========================================================");
         }
         else
         {