Win32 setup

Samples.props

@@ -5,12 +5,14 @@
   <PropertyGroup>
     <OutDir>$(SolutionDir)Build\$(Platform)_$(Configuration)\</OutDir>
     <IntDir>$(SolutionDir)Build\Intermediates\$(ProjectName)_$(Platform)_$(Configuration)\</IntDir>
+    <_PropertySheetDisplayName>Triangle</_PropertySheetDisplayName>
   </PropertyGroup>
   <ItemDefinitionGroup>
     <ClCompile>
       <ObjectFileName>$(IntDir)%(RelativeDir)</ObjectFileName>
       <AdditionalIncludeDirectories>../../DK;../Common;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>DKGL_STATIC=1;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <LanguageStandard>stdcpp17</LanguageStandard>
     </ClCompile>
   </ItemDefinitionGroup>
   <ItemGroup />

Samples/Common/app.cpp

@@ -1,11 +0,0 @@
-#include "app.h"
-
-SampleApp::SampleApp()
-{
-
-}
-
-SampleApp::~SampleApp()
-{
-
-}

Samples/Common/app.h

@@ -7,6 +7,48 @@
 class SampleApp : public DKApplication
 {
 public:
-	SampleApp();
-	~SampleApp();
+    SampleApp()
+    {
+    }
+    ~SampleApp()
+    {
+    }
+
+    void OnInitialize(void) override
+    {
+        DKLogD("%s", DKGL_FUNCTION_NAME);
+
+        DKString resPath = DefaultPath(SystemPath::AppResource);
+        resPath = resPath.FilePathStringByAppendingPath("Data");
+        DKLog("resPath: %ls", (const wchar_t*)resPath);
+        resourcePool.AddLocatorForPath(resPath);
+    }
+    void OnTerminate(void) override
+    {
+        DKLogD("%s", DKGL_FUNCTION_NAME);
+
+        DKLogI("Memory Pool Statistics");
+        size_t numBuckets = DKMemoryPoolNumberOfBuckets();
+        DKMemoryPoolBucketStatus* buckets = new DKMemoryPoolBucketStatus[numBuckets];
+        DKMemoryPoolQueryAllocationStatus(buckets, numBuckets);
+        size_t usedBytes = 0;
+        for (int i = 0; i < numBuckets; ++i)
+        {
+            if (buckets[i].totalChunks > 0)
+            {
+                DKLogI("--> %5lu:  %5lu/%5lu, usage: %.1f%%, used: %.1fKB, total: %.1fKB",
+                    buckets[i].chunkSize,
+                    buckets[i].usedChunks, buckets[i].totalChunks,
+                    double(buckets[i].usedChunks) / double(buckets[i].totalChunks) * 100.0,
+                    double(buckets[i].chunkSize * buckets[i].usedChunks) / 1024.0,
+                    double(buckets[i].chunkSize * buckets[i].totalChunks) / 1024.0
+                );
+                usedBytes += buckets[i].chunkSize * buckets[i].usedChunks;
+            }
+        }
+        DKLogI("MemoryPool Usage: %.1fMB / %.1fMB", double(usedBytes) / (1024 * 1024), double(DKMemoryPoolSize()) / (1024 * 1024));
+        delete[] buckets;
+    }
+
+    DKResourcePool resourcePool;
 };

Samples/Common/util.h

@@ -0,0 +1,272 @@
+#ifdef _WIN32
+#include "Win32/stdafx.h"
+#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";
+}
+
+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 = "";
+            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 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, "=========================================================");
+}

Samples/Data/texture.frag

@@ -0,0 +1,25 @@
+#version 450
+
+layout (binding = 1) uniform sampler2D samplerColor;
+
+layout (location = 0) in vec2 inUV;
+layout (location = 1) in float inLodBias;
+layout (location = 2) in vec3 inNormal;
+layout (location = 3) in vec3 inViewVec;
+layout (location = 4) in vec3 inLightVec;
+
+layout (location = 0) out vec4 outFragColor;
+
+void main() 
+{
+	vec4 color = texture(samplerColor, inUV, inLodBias);
+
+	vec3 N = normalize(inNormal);
+	vec3 L = normalize(inLightVec);
+	vec3 V = normalize(inViewVec);
+	vec3 R = reflect(-L, N);
+	vec3 diffuse = max(dot(N, L), 0.0) * vec3(1.0);
+	float specular = pow(max(dot(R, V), 0.0), 16.0) * color.a;
+
+	outFragColor = vec4(diffuse * color.rgb + specular, 1.0);	
+}

Samples/Data/texture.vert

@@ -0,0 +1,41 @@
+#version 450
+
+layout (location = 0) in vec3 inPos;
+layout (location = 1) in vec2 inUV;
+layout (location = 2) in vec3 inNormal;
+
+layout (binding = 0) uniform UBO 
+{
+	mat4 projection;
+	mat4 model;
+	vec4 viewPos;
+	float lodBias;
+} ubo;
+
+layout (location = 0) out vec2 outUV;
+layout (location = 1) out float outLodBias;
+layout (location = 2) out vec3 outNormal;
+layout (location = 3) out vec3 outViewVec;
+layout (location = 4) out vec3 outLightVec;
+
+out gl_PerVertex 
+{
+    vec4 gl_Position;   
+};
+
+void main() 
+{
+	outUV = inUV;
+	outLodBias = ubo.lodBias;
+
+	vec3 worldPos = vec3(ubo.model * vec4(inPos, 1.0));
+
+	gl_Position = ubo.projection * ubo.model * vec4(inPos.xyz, 1.0);
+
+    vec4 pos = ubo.model * vec4(inPos, 1.0);
+	outNormal = mat3(inverse(transpose(ubo.model))) * inNormal;
+	vec3 lightPos = vec3(0.0);
+	vec3 lPos = mat3(ubo.model) * lightPos.xyz;
+    outLightVec = lPos - pos.xyz;
+    outViewVec = ubo.viewPos.xyz - pos.xyz;		
+}

Samples/Data/triangle.frag

@@ -0,0 +1,13 @@
+#version 450
+
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+
+layout (location = 0) in vec3 inColor;
+
+layout (location = 0) out vec4 outFragColor;
+
+void main() 
+{
+  outFragColor = vec4(inColor, 1.0);
+}

Samples/Data/triangle.vert

@@ -0,0 +1,28 @@
+#version 450
+
+#extension GL_ARB_separate_shader_objects : enable
+#extension GL_ARB_shading_language_420pack : enable
+
+layout (location = 0) in vec3 inPos;
+layout (location = 1) in vec3 inColor;
+
+layout (binding = 0) uniform UBOX 
+{
+	mat4 projectionMatrix;
+	mat4 modelMatrix;
+	mat4 viewMatrix;
+} ubo;
+
+layout (location = 0) out vec3 outColor;
+
+out gl_PerVertex 
+{
+    vec4 gl_Position;   
+};
+
+
+void main() 
+{
+	outColor = inColor;
+	gl_Position = ubo.projectionMatrix * ubo.viewMatrix * ubo.modelMatrix * vec4(inPos.xyz, 1.0);
+}

Samples/Triangle/Triangle.cpp

@@ -1,243 +1,14 @@
 
 #include "app.h"
+#include "util.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";
-}
-
-void PrintShaderResource(const DKShaderResource& res, DKLogCategory c = DKLogCategory::Info)
+class TriangleDemo : public SampleApp
 {
-    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;
+    DKObject<DKWindow> window;
 	DKObject<DKThread> renderThread;
-	DKResourcePool resourcePool;
-
 	DKAtomicNumber32 runningRenderThread;
+
 public:
 	void RenderThread(void)
 	{
@@ -391,26 +162,23 @@ public:
 
 	void OnInitialize(void) override
 	{
+        SampleApp::OnInitialize();
 		DKLogD("%s", DKGL_FUNCTION_NAME);
 
-		DKString resPath = DefaultPath(SystemPath::AppResource);
-		resPath = resPath.FilePathStringByAppendingPath("Data");
-		DKLog("resPath: %ls", (const wchar_t*)resPath);
-		resourcePool.AddLocatorForPath(resPath);
+        // create window
+        window = DKWindow::Create("DefaultWindow");
+        window->SetOrigin({ 0, 0 });
+        window->Resize({ 320, 240 });
+        window->Activate();
 
-		window = DKWindow::Create("DefaultWindow");
-		window->SetOrigin({ 0, 0 });
-		window->Resize({ 320, 240 });
-		window->Activate();
-
-		window->AddEventHandler(this, DKFunction([this](const DKWindow::WindowEvent& e)
-		{
-			if (e.type == DKWindow::WindowEvent::WindowClosed)
-				DKApplication::Instance()->Terminate(0);
-		}), NULL, NULL);
+        window->AddEventHandler(this, DKFunction([this](const DKWindow::WindowEvent& e)
+        {
+            if (e.type == DKWindow::WindowEvent::WindowClosed)
+                DKApplication::Instance()->Terminate(0);
+        }), NULL, NULL);
 
 		runningRenderThread = 1;
-		renderThread = DKThread::Create(DKFunction(this, &TestApp1::RenderThread)->Invocation());
+		renderThread = DKThread::Create(DKFunction(this, &TriangleDemo::RenderThread)->Invocation());
 	}
 	void OnTerminate(void) override
 	{
@@ -419,29 +187,9 @@ public:
 		runningRenderThread = 0;
 		renderThread->WaitTerminate();
 		renderThread = NULL;
-		window = NULL;
+        window = NULL;
 
-		DKLogI("Memory Pool Statistics");
-		size_t numBuckets = DKMemoryPoolNumberOfBuckets();
-		DKMemoryPoolBucketStatus* buckets = new DKMemoryPoolBucketStatus[numBuckets];
-		DKMemoryPoolQueryAllocationStatus(buckets, numBuckets);
-		size_t usedBytes = 0;
-		for (int i = 0; i < numBuckets; ++i)
-		{
-			if (buckets[i].totalChunks > 0)
-			{
-				DKLogI("--> %5lu:  %5lu/%5lu, usage: %.1f%%, used: %.1fKB, total: %.1fKB",
-					   buckets[i].chunkSize,
-					   buckets[i].usedChunks, buckets[i].totalChunks,
-					   double(buckets[i].usedChunks) / double(buckets[i].totalChunks) * 100.0,
-					   double(buckets[i].chunkSize * buckets[i].usedChunks) / 1024.0,
-					   double(buckets[i].chunkSize * buckets[i].totalChunks) / 1024.0
-				);
-				usedBytes += buckets[i].chunkSize * buckets[i].usedChunks;
-			}
-		}
-		DKLogI("MemoryPool Usage: %.1fMB / %.1fMB", double(usedBytes) / (1024 * 1024), double(DKMemoryPoolSize()) / (1024 * 1024));
-		delete[] buckets;
+        SampleApp::OnTerminate();
 	}
 };
 
@@ -455,7 +203,7 @@ int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
 int main(int argc, const char * argv[])
 #endif
 {
-	TestApp1 app;
+    TriangleDemo app;
 	DKPropertySet::SystemConfig().SetValue("AppDelegate", "AppDelegate");
 	DKPropertySet::SystemConfig().SetValue("GraphicsAPI", "Vulkan");
 	return app.Run();

Samples/Triangle/Triangle.vcxproj

@@ -20,6 +20,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\Common\app.h" />
+    <ClInclude Include="..\Common\util.h" />
     <ClInclude Include="..\Common\Win32\Resource.h" />
     <ClInclude Include="..\Common\Win32\stdafx.h" />
     <ClInclude Include="..\Common\Win32\targetver.h" />
@@ -32,7 +33,6 @@
     <ResourceCompile Include="..\Common\Win32\SampleApp.rc" />
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="..\Common\app.cpp" />
     <ClCompile Include="..\Common\dkgl_new.cpp" />
     <ClCompile Include="Triangle.cpp" />
   </ItemGroup>
@@ -121,6 +121,11 @@
       <SubSystem>Windows</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
     </Link>
+    <PostBuildEvent>
+      <Command>echo Copying Resource Files...
+xcopy /Y /D /R /Q /E "$(SolutionDir)Samples\Data" "$(OutDir)Data\"
+</Command>
+    </PostBuildEvent>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
@@ -134,6 +139,11 @@
       <SubSystem>Windows</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
     </Link>
+    <PostBuildEvent>
+      <Command>echo Copying Resource Files...
+xcopy /Y /D /R /Q /E "$(SolutionDir)Samples\Data" "$(OutDir)Data\"
+</Command>
+    </PostBuildEvent>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
@@ -151,6 +161,11 @@
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
     </Link>
+    <PostBuildEvent>
+      <Command>echo Copying Resource Files...
+xcopy /Y /D /R /Q /E "$(SolutionDir)Samples\Data" "$(OutDir)Data\"
+</Command>
+    </PostBuildEvent>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>
@@ -168,6 +183,11 @@
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
     </Link>
+    <PostBuildEvent>
+      <Command>echo Copying Resource Files...
+xcopy /Y /D /R /Q /E "$(SolutionDir)Samples\Data" "$(OutDir)Data\"
+</Command>
+    </PostBuildEvent>
   </ItemDefinitionGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

Samples/Triangle/Triangle.vcxproj.filters

@@ -24,6 +24,9 @@
     <ClInclude Include="..\Common\app.h">
       <Filter>Common</Filter>
     </ClInclude>
+    <ClInclude Include="..\Common\util.h">
+      <Filter>Common</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Image Include="..\Common\Win32\SampleApp.ico">
@@ -45,8 +48,5 @@
     <ClCompile Include="..\Common\dkgl_new.cpp">
       <Filter>Common</Filter>
     </ClCompile>
-    <ClCompile Include="..\Common\app.cpp">
-      <Filter>Common</Filter>
-    </ClCompile>
   </ItemGroup>
 </Project>