파이프라인 정보 출력.

TestApp1/TestApp1.cpp

@@ -6,170 +6,237 @@
 #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) {
-	case DKShaderDataType::Unknown:				return "Unknown";
-	case DKShaderDataType::None:				return "None";
-
-	case DKShaderDataType::Struct:				return "Struct";
-	case DKShaderDataType::Texture:				return "Texture";
-	case DKShaderDataType::Sampler:				return "Sampler";
-
-	case DKShaderDataType::Float:				return "Float";
-	case DKShaderDataType::Float2:				return "Float2";
-	case DKShaderDataType::Float3:				return "Float3";
-	case DKShaderDataType::Float4:				return "Float4";
-
-	case DKShaderDataType::Float2x2:			return "Float2x2";
-	case DKShaderDataType::Float2x3:			return "Float2x3";
-	case DKShaderDataType::Float2x4:			return "Float2x4";
-
-	case DKShaderDataType::Float3x2:			return "Float3x2";
-	case DKShaderDataType::Float3x3:			return "Float3x3";
-	case DKShaderDataType::Float3x4:			return "Float3x4";
-
-	case DKShaderDataType::Float4x2:			return "Float4x2";
-	case DKShaderDataType::Float4x3:			return "Float4x3";
-	case DKShaderDataType::Float4x4:			return "Float4x4";
-
-	case DKShaderDataType::Half:				return "Half";
-	case DKShaderDataType::Half2:				return "Half2";
-	case DKShaderDataType::Half3:				return "Half3";
-	case DKShaderDataType::Half4:				return "Half4";
-
-	case DKShaderDataType::Half2x2:				return "Half2x2";
-	case DKShaderDataType::Half2x3:				return "Half2x3";
-	case DKShaderDataType::Half2x4:				return "Half2x4";
-
-	case DKShaderDataType::Half3x2:				return "Half3x2";
-	case DKShaderDataType::Half3x3:				return "Half3x3";
-	case DKShaderDataType::Half3x4:				return "Half3x4";
-
-	case DKShaderDataType::Half4x2:				return "Half4x2";
-	case DKShaderDataType::Half4x3:				return "Half4x3";
-	case DKShaderDataType::Half4x4:				return "Half4x4";
-
-	case DKShaderDataType::Int:					return "Int";
-	case DKShaderDataType::Int2:				return "Int2";
-	case DKShaderDataType::Int3:				return "Int3";
-	case DKShaderDataType::Int4:				return "Int4";
-
-	case DKShaderDataType::UInt:				return "UInt";
-	case DKShaderDataType::UInt2:				return "UInt2";
-	case DKShaderDataType::UInt3:				return "UInt3";
-	case DKShaderDataType::UInt4:				return "UInt4";
-
-	case DKShaderDataType::Short:				return "Short";
-	case DKShaderDataType::Short2:				return "Short2";
-	case DKShaderDataType::Short3:				return "Short3";
-	case DKShaderDataType::Short4:				return "Short4";
-
-	case DKShaderDataType::UShort:				return "UShort";
-	case DKShaderDataType::UShort2:				return "UShort2";
-	case DKShaderDataType::UShort3:				return "UShort3";
-	case DKShaderDataType::UShort4:				return "UShort4";
-
-	case DKShaderDataType::Char:				return "Char";
-	case DKShaderDataType::Char2:				return "Char2";
-	case DKShaderDataType::Char3:				return "Char3";
-	case DKShaderDataType::Char4:				return "Char4";
-
-	case DKShaderDataType::UChar:				return "UChar";
-	case DKShaderDataType::UChar2:				return "UChar2";
-	case DKShaderDataType::UChar3:				return "UChar3";
-	case DKShaderDataType::UChar4:				return "UChar4";
-
-	case DKShaderDataType::Bool:				return "Bool";
-	case DKShaderDataType::Bool2:				return "Bool2";
-	case DKShaderDataType::Bool3:				return "Bool3";
-	case DKShaderDataType::Bool4:				return "Bool4";
-	}
-	return "Error";
+    switch (t) {
+    case DKShaderDataType::Unknown:				return "Unknown";
+    case DKShaderDataType::None:				return "None";
+
+    case DKShaderDataType::Struct:				return "Struct";
+    case DKShaderDataType::Texture:				return "Texture";
+    case DKShaderDataType::Sampler:				return "Sampler";
+
+    case DKShaderDataType::Float:				return "Float";
+    case DKShaderDataType::Float2:				return "Float2";
+    case DKShaderDataType::Float3:				return "Float3";
+    case DKShaderDataType::Float4:				return "Float4";
+
+    case DKShaderDataType::Float2x2:			return "Float2x2";
+    case DKShaderDataType::Float2x3:			return "Float2x3";
+    case DKShaderDataType::Float2x4:			return "Float2x4";
+
+    case DKShaderDataType::Float3x2:			return "Float3x2";
+    case DKShaderDataType::Float3x3:			return "Float3x3";
+    case DKShaderDataType::Float3x4:			return "Float3x4";
+
+    case DKShaderDataType::Float4x2:			return "Float4x2";
+    case DKShaderDataType::Float4x3:			return "Float4x3";
+    case DKShaderDataType::Float4x4:			return "Float4x4";
+
+    case DKShaderDataType::Half:				return "Half";
+    case DKShaderDataType::Half2:				return "Half2";
+    case DKShaderDataType::Half3:				return "Half3";
+    case DKShaderDataType::Half4:				return "Half4";
+
+    case DKShaderDataType::Half2x2:				return "Half2x2";
+    case DKShaderDataType::Half2x3:				return "Half2x3";
+    case DKShaderDataType::Half2x4:				return "Half2x4";
+
+    case DKShaderDataType::Half3x2:				return "Half3x2";
+    case DKShaderDataType::Half3x3:				return "Half3x3";
+    case DKShaderDataType::Half3x4:				return "Half3x4";
+
+    case DKShaderDataType::Half4x2:				return "Half4x2";
+    case DKShaderDataType::Half4x3:				return "Half4x3";
+    case DKShaderDataType::Half4x4:				return "Half4x4";
+
+    case DKShaderDataType::Int:					return "Int";
+    case DKShaderDataType::Int2:				return "Int2";
+    case DKShaderDataType::Int3:				return "Int3";
+    case DKShaderDataType::Int4:				return "Int4";
+
+    case DKShaderDataType::UInt:				return "UInt";
+    case DKShaderDataType::UInt2:				return "UInt2";
+    case DKShaderDataType::UInt3:				return "UInt3";
+    case DKShaderDataType::UInt4:				return "UInt4";
+
+    case DKShaderDataType::Short:				return "Short";
+    case DKShaderDataType::Short2:				return "Short2";
+    case DKShaderDataType::Short3:				return "Short3";
+    case DKShaderDataType::Short4:				return "Short4";
+
+    case DKShaderDataType::UShort:				return "UShort";
+    case DKShaderDataType::UShort2:				return "UShort2";
+    case DKShaderDataType::UShort3:				return "UShort3";
+    case DKShaderDataType::UShort4:				return "UShort4";
+
+    case DKShaderDataType::Char:				return "Char";
+    case DKShaderDataType::Char2:				return "Char2";
+    case DKShaderDataType::Char3:				return "Char3";
+    case DKShaderDataType::Char4:				return "Char4";
+
+    case DKShaderDataType::UChar:				return "UChar";
+    case DKShaderDataType::UChar2:				return "UChar2";
+    case DKShaderDataType::UChar3:				return "UChar3";
+    case DKShaderDataType::UChar4:				return "UChar4";
+
+    case DKShaderDataType::Bool:				return "Bool";
+    case DKShaderDataType::Bool2:				return "Bool2";
+    case DKShaderDataType::Bool3:				return "Bool3";
+    case DKShaderDataType::Bool4:				return "Bool4";
+    }
+    return "Error";
 }
 
-void PrintShaderResource(const DKShaderResource& res)
+void PrintShaderResource(const DKShaderResource& res, DKLogCategory c = DKLogCategory::Info)
 {
-	struct MemberPrinter
-	{
-		const DKShaderResource& res;
-		int indent;
-		void operator()(const DKShaderResourceStruct& str) const
-		{
-			DKString indentStr = "";
-			for (int i = 0; i < indent; ++i)
-			{
-				indentStr += "    ";
-			}
-			for (const DKShaderResourceStructMember& mem : str.members)
-			{
-				if (mem.count > 1)
-				{
-					DKLogI(" %ls+ %ls[%d] (%s, Offset: %d, Size: %d, Stride: %d)",
-						   (const wchar_t*)indentStr,
-						   (const wchar_t*)mem.name,
-						   mem.count,
-						   ShaderDataTypeStr(mem.dataType),
-						   mem.offset, mem.size, mem.stride);
-
-				}
-				else
-				{
-					DKLogI(" %ls+ %ls (%s, Offset: %d, Size: %d)",
-						   (const wchar_t*)indentStr,
-						   (const wchar_t*)mem.name,
-						   ShaderDataTypeStr(mem.dataType),
-						   mem.offset, mem.size);
-				}
-
-				auto* p = res.structTypeMemberMap.Find(mem.typeInfoKey);
-				if (p)
-				{
-					DKLogI(" %ls+TypeKey: %ls (struct)",
-						   (const wchar_t*)indentStr,
-						   (const wchar_t*)res.typeInfoKey);
-					MemberPrinter{ res, indent + 1 }.operator()(p->value);
-				}
-			}
-		}
-	};
-	if (res.count > 1)
-		DKLogI("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);
-
-	const char* type = "Unknown (ERROR)";
-	switch (res.type)
-	{
-	case DKShaderResource::TypeBuffer: type = "Buffer"; break;
-	case DKShaderResource::TypeTexture:	type = "Texture"; break;
-	case DKShaderResource::TypeSampler:	type = "Sampler"; break;
-	case DKShaderResource::TypeThreadgroupMemory:	type = "Threadinggroup"; break;
-	}
-	const char* access = "Unknown (ERROR)";
-	switch (res.access)
-	{
-		case DKShaderResource::AccessReadOnly:	access = "ReadOnly"; break;
-		case DKShaderResource::AccessWriteOnly:	access = "WriteOnly"; break;
-		case DKShaderResource::AccessReadWrite:	access = "ReadWrite"; break;
-	}
-	DKLogI(" +Type:%s, Access:%s, Enabled:%d Alignment:%d, Size:%d",
-		   type,
-		   access,
-		   int(res.enabled),
-		   res.typeInfo.buffer.alignment,
-		   res.typeInfo.buffer.size);
-	if (res.typeInfoKey.Length() > 0)
-		DKLogI(" +TypeKey: %ls (struct)", (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);
-	}
+    struct MemberPrinter
+    {
+        const DKShaderResource& res;
+        int indent;
+        DKLogCategory c;
+        void operator()(const DKShaderResourceStruct& str) const
+        {
+            DKString indentStr = "";
+            for (int i = 0; i < indent; ++i)
+            {
+                indentStr += "    ";
+            }
+            for (const DKShaderResourceStructMember& mem : str.members)
+            {
+                if (mem.count > 1)
+                {
+                    DKLog(c, " %ls+ %ls[%d] (%s, Offset: %d, Stride: %d)",
+                        (const wchar_t*)indentStr,
+                          (const wchar_t*)mem.name,
+                          mem.count,
+                          ShaderDataTypeStr(mem.dataType),
+                          mem.offset, mem.stride);
+
+                }
+                else
+                {
+                    DKLog(c, " %ls+ %ls (%s, Offset: %d)",
+                        (const wchar_t*)indentStr,
+                          (const wchar_t*)mem.name,
+                          ShaderDataTypeStr(mem.dataType),
+                          mem.offset);
+                }
+
+                auto* p = res.structTypeMemberMap.Find(mem.typeInfoKey);
+                if (p)
+                {
+                    DKLog(c, " %ls  Struct \"%ls\"",
+                        (const wchar_t*)indentStr,
+                          (const wchar_t*)mem.typeInfoKey);
+                    MemberPrinter{ res, indent + 1, c}.operator()(p->value);
+                }
+            }
+        }
+    };
+
+
+    if (res.count > 1)
+        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, 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)
+    {
+    case DKShaderResource::TypeBuffer: type = "Buffer"; break;
+    case DKShaderResource::TypeTexture:	type = "Texture"; break;
+    case DKShaderResource::TypeSampler:	type = "Sampler"; break;
+    case DKShaderResource::TypeTextureSampler: type = "SampledTexture"; break;
+    }
+    const char* access = "Unknown (ERROR)";
+    switch (res.access)
+    {
+    case DKShaderResource::AccessReadOnly:	access = "ReadOnly"; break;
+    case DKShaderResource::AccessWriteOnly:	access = "WriteOnly"; break;
+    case DKShaderResource::AccessReadWrite:	access = "ReadWrite"; break;
+    }
+
+    if (res.type == DKShaderResource::TypeBuffer)
+    {
+        DKLog(c, " Type:%s, Access:%s, Enabled:%d, Size:%d",
+              type,
+              access,
+              int(res.enabled),
+              res.typeInfo.buffer.size);
+    }
+    else
+    {
+        DKLog(c, " Type:%s, Access:%s, Enabled:%d",
+              type,
+              access,
+              int(res.enabled));
+    }
+    if (res.typeInfoKey.Length() > 0)
+        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 , c}.operator()(p->value);
+    }
 }
 
+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, "=========================================================");
+}
+
+
 class TestApp1 : public DKApplication
 {
 	DKObject<DKWindow> window;
@@ -182,8 +249,8 @@ public:
 	{
 		DKObject<DKData> vertData = resourcePool.LoadResourceData("triangle.vert.spv");
 		DKObject<DKData> fragData = resourcePool.LoadResourceData("triangle.frag.spv");
-		DKShader vertShader(vertData, DKShader::Vertex);
-		DKShader fragShader(fragData, DKShader::Fragment);
+		DKShader vertShader(vertData);
+		DKShader fragShader(fragData);
 
 		DKObject<DKGraphicsDevice> device = DKGraphicsDevice::SharedInstance();
 		DKObject<DKShaderModule> vertShaderModule = device->CreateShaderModule(&vertShader);
@@ -195,10 +262,10 @@ public:
 		DKObject<DKCommandQueue> queue = device->CreateCommandQueue(DKCommandQueue::Graphics);
 		DKObject<DKSwapChain> swapChain = queue->CreateSwapChain(window);
 
-		DKLog("VertexFunction.VertexAttributes: %d", vertShaderFunction->VertexAttributes().Count());
-		for (int i = 0; i < vertShaderFunction->VertexAttributes().Count(); ++i)
+		DKLog("VertexFunction.VertexAttributes: %d", vertShaderFunction->StageInputAttributes().Count());
+		for (int i = 0; i < vertShaderFunction->StageInputAttributes().Count(); ++i)
 		{
-			const DKVertexAttribute& attr = vertShaderFunction->VertexAttributes().Value(i);
+			const DKShaderAttribute& attr = vertShaderFunction->StageInputAttributes().Value(i);
 			DKLog("  --> VertexAttribute[%d]: \"%ls\" (location:%u)", i, (const wchar_t*)attr.name, attr.location);
 		}
 
@@ -245,16 +312,11 @@ public:
 		pipelineDescriptor.cullMode = DKCullMode::None;
 		pipelineDescriptor.rasterizationEnabled = true;
 
-		DKRenderPipelineReflection reflection;
+		DKPipelineReflection reflection;
 		DKObject<DKRenderPipelineState> pipelineState = device->CreateRenderPipeline(pipelineDescriptor, &reflection);
 		if (pipelineState)
 		{
-			DKLog("PipelineReflection.VertexResources: %d", reflection.vertexResources.Count());
-			for (auto& arg : reflection.vertexResources)
-				PrintShaderResource(arg);
-			DKLog("PipelineReflection.FragmentResources: %d", reflection.fragmentResources.Count());
-			for (auto& arg : reflection.fragmentResources)
-				PrintShaderResource(arg);
+            PrintPipelineReflection(&reflection, DKLogCategory::Verbose);
 		}
 
 		DKTimer timer;

TestApp1/TestApp1.vcxproj

@@ -96,6 +96,7 @@
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>DKGL_STATIC=1;WIN32;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../DK</AdditionalIncludeDirectories>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -117,6 +118,7 @@ xcopy /Y /D /R /Q /E "$(SolutionDir)Data" "$(OutDir)Data\"
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>DKGL_STATIC=1;_DEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../DK</AdditionalIncludeDirectories>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -140,6 +142,7 @@ xcopy /Y /D /R /Q /E "$(SolutionDir)Data" "$(OutDir)Data\"
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>DKGL_STATIC=1;WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../DK</AdditionalIncludeDirectories>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>
@@ -165,6 +168,7 @@ xcopy /Y /D /R /Q /E "$(SolutionDir)Data" "$(OutDir)Data\"
       <IntrinsicFunctions>true</IntrinsicFunctions>
       <PreprocessorDefinitions>DKGL_STATIC=1;NDEBUG;_WINDOWS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <AdditionalIncludeDirectories>../DK</AdditionalIncludeDirectories>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Windows</SubSystem>