feat : wip - abstract mesh for scene

Samples/Data/shaders/ObjMeshShader/objmesh.frag

@@ -0,0 +1,13 @@
+#version 450
+
+layout (binding = 1) uniform sampler2D samplerColor;
+
+layout (location = 0) in vec3 fragColor;
+layout (location = 1) in vec2 fragTexCoord;
+
+layout (location = 0) out vec4 outFragColor;
+
+void main() 
+{
+	outFragColor = texture(samplerColor, fragTexCoord);
+}

Samples/Data/shaders/ObjMeshShader/objmesh.vert

@@ -0,0 +1,28 @@
+#version 450
+
+layout (location = 0) in vec3 inPos;
+layout (location = 1) in vec3 inColor;
+layout (location = 2) in vec3 inNormal;
+layout (location = 3) in vec2 inTexCoord;
+
+layout (binding = 0) uniform UBO
+{
+	mat4 projection;
+	mat4 model;
+	mat4 view;
+} ubo;
+
+layout (location = 0) out vec3 fragColor;
+layout (location = 1) out vec2 fragTexCoord;
+
+out gl_PerVertex
+{
+    vec4 gl_Position;
+};
+
+void main()
+{
+	gl_Position = ubo.projection * ubo.view * ubo.model * vec4(inPos, 1.0);
+	fragColor = inColor;
+	fragTexCoord = inTexCoord;
+}

Samples/PBRScene/DKGLDemoScene.cpp

@@ -0,0 +1,256 @@
+#include <cstddef>
+#include "app.h"
+#include "util.h"
+
+#include "StaticMesh.h"
+
+struct SceneUniformBuffer
+{
+    DKMatrix4 projectionMatrix;
+    DKMatrix4 modelMatrix;
+    DKMatrix4 viewMatrix;
+};
+
+class DKGLDemo : public SampleApp
+{
+    DKObject<DKWindow> window;
+	DKObject<DKThread> renderThread;
+	DKAtomicNumber32 runningRenderThread;
+	DKObject<StaticMesh> sampleMesh;
+
+    DKObject<DKGpuBuffer> sceneUniformBuffer;
+    SceneUniformBuffer* sceneBufferData = nullptr;
+
+public:
+    void LoadResource()
+    {
+        DKString vertexShaderPath
+            = resourcePool.ResourceFilePath("shaders/ObjMeshShader/objmesh.vert.spv");
+        DKString fragMentShaderPath
+            = resourcePool.ResourceFilePath("shaders/ObjMeshShader/objmesh.frag.spv");
+        DKString texturePath
+            = resourcePool.ResourceFilePath("meshes/VikingRoom/viking_room.png");
+
+        sampleMesh->LoadShaderFromFile(resourcePool, vertexShaderPath, DKShaderStage::Vertex);
+        sampleMesh->LoadShaderFromFile(resourcePool, fragMentShaderPath, DKShaderStage::Fragment);
+        sampleMesh->LoadTextureFromFile(resourcePool, texturePath);
+    }
+
+	void LoadRenderResource(DKObject<DKCommandQueue> queue)
+	{
+		DKLog("Loading Static Meshes");
+        DKString path = resourcePool.ResourceFilePath("meshes/VikingRoom/viking_room.obj");
+        sampleMesh->LoadMeshResourceFromFile(queue->Device(), resourcePool, path);
+        sampleMesh->LoadRenderResourceShader(queue->Device(), DKShaderStage::Vertex);
+        sampleMesh->LoadRenderResourceShader(queue->Device(), DKShaderStage::Fragment);
+        sampleMesh->LoadRenderResourceTexture(queue);
+	}
+
+    void SetupPipeline(DKRenderPipelineDescriptor& pipelineDesc)
+    {
+        sampleMesh->SetupPipelineDecriptor(pipelineDesc);
+    }
+
+    void SetupMaterial(DKObject<DKGraphicsDevice> device)
+    {
+        sampleMesh->SetupMaterial(device);
+    }
+
+    void SetupSceneUniformBuffer(DKObject<DKGraphicsDevice> device)
+    {
+        // should Go to Scene Uniform Buffer
+        sceneUniformBuffer = device->CreateBuffer(sizeof(SceneUniformBuffer)
+            , DKGpuBuffer::StorageModeShared, DKCpuCacheModeReadWrite);
+
+        sceneBufferData = reinterpret_cast<SceneUniformBuffer*>(sceneUniformBuffer->Contents());
+        sceneBufferData->projectionMatrix = DKMatrix4::identity;
+        sceneBufferData->modelMatrix = DKMatrix4::identity;
+        sceneBufferData->viewMatrix = DKMatrix4::identity;
+        sceneUniformBuffer->Flush();
+
+        //DKAffineTransform3 trans;
+        //trans.Multiply(DKLinearTransform3().Scale(0.5).Rotate(DKVector3(0,1,0), DKGL_PI * 0.5));
+        //ubo.modelMatrix.Multiply(trans.Matrix4());
+
+        //memcpy(uboBuffer->Contents(), &ubo, sizeof(ubo));
+
+        sampleMesh->SetupExternalUniformBuffer(sceneUniformBuffer, sizeof(SceneUniformBuffer), 0);
+    }
+
+    void EncodeScene(DKObject<DKRenderCommandEncoder> encoder)
+    {
+        sampleMesh->EncodeRenderCommand(encoder);
+    }
+
+	void RenderThread(void)
+	{
+		DKObject<DKGraphicsDevice> device = DKGraphicsDevice::SharedInstance();
+        DKObject<DKCommandQueue> queue = device->CreateCommandQueue(DKCommandQueue::Graphics);
+
+        LoadRenderResource(queue);
+
+		DKObject<DKSwapChain> swapChain = queue->CreateSwapChain(window);
+
+		DKRenderPipelineDescriptor pipelineDescriptor;
+        // setup color-attachment render-targets
+        pipelineDescriptor.colorAttachments.Resize(1);
+        pipelineDescriptor.colorAttachments.Value(0).pixelFormat = swapChain->ColorPixelFormat();
+        pipelineDescriptor.colorAttachments.Value(0).blendState.enabled = false;
+        pipelineDescriptor.colorAttachments.Value(0).blendState.sourceRGBBlendFactor = DKBlendFactor::SourceAlpha;
+        pipelineDescriptor.colorAttachments.Value(0).blendState.destinationRGBBlendFactor = DKBlendFactor::OneMinusSourceAlpha;
+        // setup depth-stencil
+        pipelineDescriptor.depthStencilAttachmentPixelFormat = DKPixelFormat::D32Float;
+        pipelineDescriptor.depthStencilDescriptor.depthWriteEnabled = true;
+        pipelineDescriptor.depthStencilDescriptor.depthCompareFunction = DKCompareFunctionLessEqual;
+        // setup topology and rasterization
+        pipelineDescriptor.primitiveTopology = DKPrimitiveType::Triangle;
+        pipelineDescriptor.frontFace = DKFrontFace::CCW;
+        pipelineDescriptor.triangleFillMode = DKTriangleFillMode::Fill;
+        pipelineDescriptor.depthClipMode = DKDepthClipMode::Clip;
+        pipelineDescriptor.cullMode = DKCullMode::Back;
+        pipelineDescriptor.rasterizationEnabled = true;
+
+        SetupPipeline(pipelineDescriptor);
+
+		DKPipelineReflection reflection;
+		DKObject<DKRenderPipelineState> pipelineState = device->CreateRenderPipeline(pipelineDescriptor, &reflection);
+		if (pipelineState)
+		{
+            PrintPipelineReflection(&reflection, DKLogCategory::Verbose);
+		}
+
+        SetupMaterial(device);
+        SetupSceneUniformBuffer(device);
+
+        DKObject<DKTexture> depthBuffer = nullptr;
+
+        DKCamera camera;
+        DKVector3 cameraPosition = { 0, 5, 10 };
+        DKVector3 cameraTartget = { 0, 0, 0 };
+
+        DKAffineTransform3 tm(DKLinearTransform3().Scale(5).Rotate(DKVector3(-1,0,0), DKGL_PI * 0.5));
+
+        DKTimer timer;
+		timer.Reset();
+
+		DKLog("Render thread begin");
+		while (!runningRenderThread.CompareAndSet(0, 0))
+		{
+			DKRenderPassDescriptor rpd = swapChain->CurrentRenderPassDescriptor();
+			double t = timer.Elapsed();
+			double waveT = (cos(t) + 1.0) * 0.5;
+			rpd.colorAttachments.Value(0).clearColor = DKColor(waveT, 0.0, 0.0, 0.0);
+
+            int width = rpd.colorAttachments.Value(0).renderTarget->Width();
+            int height = rpd.colorAttachments.Value(0).renderTarget->Height();
+            if (depthBuffer)
+            {
+                if (depthBuffer->Width() !=  width ||
+                    depthBuffer->Height() != height )
+                    depthBuffer = nullptr;
+            }
+            if (depthBuffer == nullptr)
+            {
+                // create depth buffer
+                DKTextureDescriptor texDesc = {};
+                texDesc.textureType = DKTexture::Type2D;
+                texDesc.pixelFormat = DKPixelFormat::D32Float;
+                texDesc.width = width;
+                texDesc.height = height;
+                texDesc.depth = 1;
+                texDesc.mipmapLevels = 1;
+                texDesc.sampleCount = 1;
+                texDesc.arrayLength = 1;
+                texDesc.usage = DKTexture::UsageRenderTarget;
+                depthBuffer = device->CreateTexture(texDesc);
+            }
+            rpd.depthStencilAttachment.renderTarget = depthBuffer;
+            rpd.depthStencilAttachment.loadAction = DKRenderPassAttachmentDescriptor::LoadActionClear;
+            rpd.depthStencilAttachment.storeAction = DKRenderPassAttachmentDescriptor::StoreActionDontCare;
+
+			DKObject<DKCommandBuffer> buffer = queue->CreateCommandBuffer();
+			DKObject<DKRenderCommandEncoder> encoder = buffer->CreateRenderCommandEncoder(rpd);
+			if (encoder)
+			{
+                if (sceneUniformBuffer)
+                {
+                    camera.SetView(cameraPosition, cameraTartget - cameraPosition, DKVector3(0, 1, 0));
+                    camera.SetPerspective(DKGL_DEGREE_TO_RADIAN(90), float(width)/float(height), 1, 1000);
+
+                    sceneBufferData->projectionMatrix = camera.ProjectionMatrix();
+                    sceneBufferData->viewMatrix = camera.ViewMatrix();
+
+                    DKQuaternion quat(DKVector3(0, 1, 0), t);
+                    DKAffineTransform3 trans = tm * DKAffineTransform3(quat);
+                    sceneBufferData->modelMatrix = trans.Matrix4();
+                    sceneUniformBuffer->Flush();
+
+                    sampleMesh->SetupExternalUniformBuffer(sceneUniformBuffer, sizeof(SceneUniformBuffer), 0);
+                }
+
+				encoder->SetRenderPipelineState(pipelineState);
+
+                EncodeScene(encoder);
+
+                buffer->Commit();
+				swapChain->Present();
+			}
+			else
+			{
+			}
+			DKThread::Sleep(0.01);
+		}
+		DKLog("RenderThread terminating...");
+	}
+
+	void OnInitialize(void) override
+	{
+        SampleApp::OnInitialize();
+		DKLogD("%s", DKGL_FUNCTION_NAME);
+
+        // create window
+        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);
+
+        sampleMesh = DKObject<StaticMesh>::New();
+        LoadResource();
+
+		runningRenderThread = 1;
+		renderThread = DKThread::Create(DKFunction(this, &DKGLDemo::RenderThread)->Invocation());
+	}
+	void OnTerminate(void) override
+	{
+		DKLogD("%s", DKGL_FUNCTION_NAME);
+
+		runningRenderThread = 0;
+		renderThread->WaitTerminate();
+		renderThread = NULL;
+        window = NULL;
+
+        SampleApp::OnTerminate();
+	}
+};
+
+
+#ifdef _WIN32
+int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
+					  _In_opt_ HINSTANCE hPrevInstance,
+					  _In_ LPWSTR    lpCmdLine,
+					  _In_ int       nCmdShow)
+#else
+int main(int argc, const char * argv[])
+#endif
+{
+    DKGLDemo app;
+	DKPropertySet::SystemConfig().SetValue("AppDelegate", "AppDelegate");
+	DKPropertySet::SystemConfig().SetValue("GraphicsAPI", "Vulkan");
+	return app.Run();
+}

Samples/PBRScene/ObjImportUtil.cpp

@@ -0,0 +1,109 @@
+#include "ObjImportUtil.h"
+#include "tiny_obj_loader.h"
+
+
+int ObjImportUtil::ObjVertex::Compare(const ObjVertex& Other) const
+{
+    const float pp[] = { this->inPos.x, this->inPos.y, this->inPos.z,
+        this->inColor.x, this->inColor.y, this->inColor.z,
+        this->inTexCoord.x, this->inTexCoord.y,
+        this->inNormal.x, this->inNormal.y, this->inNormal.z };
+    const float rr[] = { Other.inPos.x, Other.inPos.y, Other.inPos.z,
+        Other.inColor.x, Other.inColor.y, Other.inColor.z,
+        Other.inTexCoord.x, Other.inTexCoord.y,
+        Other.inNormal.x, Other.inNormal.y, Other.inNormal.z };
+
+    for (int i = 0; i < std::size(pp); ++i)
+    {
+        auto k = pp[i] - rr[i];
+        if (abs(k) < 0.0001)
+            continue;
+        if (k > 0)
+            return 1;
+        else if (k < 0)
+            return -1;
+    }
+    return 0;
+}
+
+
+ObjImportUtil::ObjImportedMeshData ObjImportUtil::LoadFromObjFile(
+    const DKString& inPath
+    , DKResourcePool& inDKResourcePool)
+{
+    ObjImportedMeshData retData;
+
+    DKObject<DKData> objData = inDKResourcePool.LoadResourceData(inPath);
+    if (objData && objData->Length() > 0)
+    {
+        DKLog("Loading %ls... (%lu bytes)\n"
+            , (const wchar_t*)inPath
+            , objData->Length());
+
+        DKTimer timer;
+        timer.Reset();
+
+        retData.vertices.Reserve(100000);
+        retData.indices.Reserve(100000);
+        retData.vertexSize = sizeof(ObjImportUtil::ObjVertex);
+
+        tinyobj::attrib_t attrib;
+        std::vector<tinyobj::shape_t> shapes;
+        shapes.reserve(1000000);
+        std::vector<tinyobj::material_t> materials;
+
+        std::string err;
+        if (!tinyobj::LoadObj(&attrib, &shapes, &materials, &err, DKStringU8(inPath))) {
+            throw std::runtime_error(err);
+        }
+
+        DKMap<ObjVertex, uint32_t> uniqueVertices;
+
+        DKLog("Save to Container");
+        for (const auto& shape : shapes)
+        {
+            for (const auto& index : shape.mesh.indices)
+            {
+                ObjVertex vertex = {};
+
+                vertex.inPos = {
+                    attrib.vertices[3 * index.vertex_index + 0],
+                    attrib.vertices[3 * index.vertex_index + 1],
+                    attrib.vertices[3 * index.vertex_index + 2]
+                };
+
+                if (attrib.texcoords.size())
+                {
+                    vertex.inTexCoord = {
+                    attrib.texcoords[2 * index.texcoord_index + 0],
+                    1.0f - attrib.texcoords[2 * index.texcoord_index + 1]
+                    };
+                }
+
+                vertex.inColor = { 1.0f, 1.0f, 1.0f };
+
+                if (attrib.normals.size())
+                {
+                    vertex.inNormal = {
+                        attrib.normals[3 * index.normal_index + 0],
+                        attrib.normals[3 * index.normal_index + 1],
+                        attrib.normals[3 * index.normal_index + 2]
+                    };
+                }
+
+                if (uniqueVertices.Find(vertex) == nullptr)
+                {
+                    uniqueVertices.Insert(vertex
+                        , static_cast<uint32_t>(retData.vertices.Count()));
+                    retData.vertices.Add(vertex);
+                }
+
+                retData.indices.Add(uniqueVertices.Value(vertex));
+
+                retData.aabb.Expand(vertex.inPos);
+            }
+        }
+    }
+
+    return retData;
+}

Samples/PBRScene/ObjImportUtil.h

@@ -0,0 +1,43 @@
+// Simple Obj Loader from https://www.dkscript.com/wiki/SampleCodes/ObjLoader
+// but using tinyObjLoader for MTL convenience
+
+#pragma once
+
+#include <DK.h>
+
+class ObjImportUtil
+{
+public:
+    struct ObjVertex
+    {
+        DKVector3 inPos;
+        DKVector3 inColor;
+        DKVector3 inNormal;
+        DKVector2 inTexCoord;
+
+        int Compare(const ObjVertex& Other) const;
+
+        inline bool operator > (const ObjVertex& Other) const
+        {
+            return Compare(Other) > 0;
+        }
+
+        inline bool operator < (const ObjVertex& Other) const
+        {
+            return Compare(Other) < 0;
+        }
+    };
+
+    struct ObjImportedMeshData
+    {
+        DKArray<ObjVertex> vertices;
+        DKArray<uint32_t> indices;
+        DKAabb aabb;
+        uint32_t vertexSize;
+    };
+
+    static ObjImportedMeshData LoadFromObjFile(
+        const DKString& inPath
+        , DKResourcePool& inDKResourcePool);
+};
+

Samples/PBRScene/PBRScene.cpp

@@ -1,468 +0,0 @@
-#include <cstddef>
-#include "app.h"
-#include "util.h"
-
-#define TINYOBJLOADER_IMPLMENTATION
-#include "tiny_obj_loader.h"
-#include <unordered_map>
-
-
-class SampleObjMesh
-{
-public:
-	struct Vertex
-	{
-		DKVector3 inPos;
-		DKVector3 inColor;
-		DKVector2 intexCoord;
-
-		int Compare(const Vertex& Other) const
-		{
-            const float pp[] = { this->inPos.x, this->inPos.y, this->inPos.z,
-                this->inColor.x, this->inColor.y, this->inColor.z,
-                this->intexCoord.x, this->intexCoord.y};
-            const float rr[] = { Other.inPos.x, Other.inPos.y, Other.inPos.z,
-                Other.inColor.x, Other.inColor.y, Other.inColor.z,
-                Other.intexCoord.x, Other.intexCoord.y};
-
-            for (int i = 0; i < std::size(pp); ++i)
-            {
-                auto k = pp[i] - rr[i];
-                if (abs(k) < 0.0001)
-                    continue;
-                if (k > 0)
-                    return 1;
-                else if (k < 0)
-                    return -1;
-            }
-            return 0;
-		}
-
-		bool operator > (const Vertex& Other) const
-		{
-			return Compare(Other) > 0;
-		}
-
-		bool operator < (const Vertex& Other) const
-		{
-			return Compare(Other) < 0;
-		}
-	};
-
-	SampleObjMesh()
-	{
-		vertices.Reserve(100);
-		indices.Reserve(100);
-	}
-
-	void LoadFromObjFile(const char* InPath)
-	{
-		tinyobj::attrib_t attrib;
-		std::vector<tinyobj::shape_t> shapes;
-		std::vector<tinyobj::material_t> materials;
-		std::string err;
-		if (!tinyobj::LoadObj(&attrib, &shapes, &materials, &err, InPath)) {
-			throw std::runtime_error(err);
-		}
-
-		DKMap<Vertex, uint32_t> uniqueVertices;
-		DKLog("Save to Container");
-		for (const auto& shape : shapes)
-		{
-			for (const auto& index : shape.mesh.indices)
-			{
-				Vertex vertex = {};
-
-				vertex.inPos = {
-					attrib.vertices[3 * index.vertex_index + 0],
-					attrib.vertices[3 * index.vertex_index + 1],
-					attrib.vertices[3 * index.vertex_index + 2]
-				};
-
-				if (attrib.texcoords.size())
-				{
-					vertex.intexCoord = {
-					attrib.texcoords[2 * index.texcoord_index + 0],
-					1.0f - attrib.texcoords[2 * index.texcoord_index + 1]
-					};
-				}
-
-				vertex.inColor = { 1.0f, 1.0f, 1.0f };
-
-				if (uniqueVertices.Find(vertex) == nullptr)
-				{
-					uniqueVertices.Insert(vertex, static_cast<uint32_t>(vertices.Count()));
-					vertices.Add(vertex);
-				}
-
-				indices.Add(uniqueVertices.Value(vertex));
-
-                aabb.Expand(vertex.inPos);
-			}
-		}
-	}
-
-	uint32_t GetVerticesCount() const {
-		return static_cast<uint32_t>(vertices.Count()); };
-	uint32_t GetIndicesCount() const {
-		return static_cast<uint32_t>(indices.Count()); };
-	const Vertex* GetVerticesData() const {
-		return vertices; }
-	const uint32_t* GetIndicesData() const {
-		return indices; }
-
-    DKAabb aabb;
-private:
-	DKArray<Vertex> vertices;
-	DKArray<uint32_t> indices;
-	DKSpinLock                  MeshLock;
-};
-
-///// Template Spealization for DKString. (for DKMap, DKSet)
-//template <> struct DKMapKeyComparator<SampleObjMesh::Vertex>
-//{
-//	int operator () (const DKStringW& lhs, const DKStringW& rhs) const
-//	{
-//		return lhs.Compare(rhs);
-//	}
-//};
-
-
-class MeshDemo : public SampleApp
-{
-    DKObject<DKWindow> window;
-	DKObject<DKThread> renderThread;
-	DKAtomicNumber32 runningRenderThread;
-	DKObject<SampleObjMesh> SampleMesh;
-
-public:
-	void LoadMesh()
-	{
-
-		DKLog("Loading Mesh");
-        DKString path = resourcePool.ResourceFilePath("meshes/chalet/chalet.obj");
-		SampleMesh->LoadFromObjFile(DKStringU8(path));
-	}
-
-    DKObject<DKTexture> LoadTexture2D(DKCommandQueue* queue, DKData* data)
-    {
-        DKObject<DKImage> image = DKImage::Create(data);
-        if (image)
-        {
-            DKGraphicsDevice* device = queue->Device();
-            DKTextureDescriptor texDesc = {};
-            texDesc.textureType = DKTexture::Type2D;
-            texDesc.pixelFormat = DKPixelFormat::RGBA8Unorm;
-            texDesc.width = image->Width();
-            texDesc.height = image->Height();
-            texDesc.depth = 1;
-            texDesc.mipmapLevels = 1;
-            texDesc.sampleCount = 1;
-            texDesc.arrayLength = 1;
-            texDesc.usage = DKTexture::UsageCopyDestination | DKTexture::UsageSampled;
-            DKObject<DKTexture> tex = device->CreateTexture(texDesc);
-            if (tex)
-            {
-                size_t bytesPerPixel = image->BytesPerPixel();
-                DKASSERT_DESC(bytesPerPixel == DKPixelFormatBytesPerPixel(texDesc.pixelFormat), "BytesPerPixel mismatch!");
-
-                uint32_t width = image->Width();
-                uint32_t height = image->Height();
-
-                size_t bufferLength = bytesPerPixel * width * height;
-                DKObject<DKGpuBuffer> stagingBuffer = device->CreateBuffer(bufferLength, DKGpuBuffer::StorageModeShared, DKCpuCacheModeReadWrite);
-
-                memcpy(stagingBuffer->Contents(), image->Contents(), bufferLength);
-                stagingBuffer->Flush();
-
-                DKObject<DKCommandBuffer> cb = queue->CreateCommandBuffer();
-                DKObject<DKCopyCommandEncoder> encoder = cb->CreateCopyCommandEncoder();
-                encoder->CopyFromBufferToTexture(stagingBuffer,
-                                                 { 0, width, height },
-                                                 tex,
-                                                 { 0,0, 0,0,0 },
-                                                 { width,height,1 });
-                encoder->EndEncoding();
-                cb->Commit();
-
-                DKLog("Texture created!");
-                return tex;
-            }
-        }
-        return nullptr;
-    }
-	void RenderThread(void)
-	{
-		DKObject<DKData> vertData = resourcePool.LoadResourceData("shaders/mesh.vert.spv");
-		DKObject<DKData> fragData = resourcePool.LoadResourceData("shaders/mesh.frag.spv");
-		DKShader vertShader(vertData);
-		DKShader fragShader(fragData);
-
-		DKObject<DKGraphicsDevice> device = DKGraphicsDevice::SharedInstance();
-        DKObject<DKCommandQueue> queue = device->CreateCommandQueue(DKCommandQueue::Graphics);
-
-		// create texture
-		DKObject<DKTexture> texture = LoadTexture2D(queue, resourcePool.LoadResourceData("meshes/chalet.png"));
-		// create sampler
-		DKSamplerDescriptor samplerDesc = {};
-		samplerDesc.magFilter = DKSamplerDescriptor::MinMagFilterLinear;
-		samplerDesc.minFilter = DKSamplerDescriptor::MinMagFilterLinear;
-		samplerDesc.addressModeU = DKSamplerDescriptor::AddressModeClampToEdge;
-		samplerDesc.addressModeV = DKSamplerDescriptor::AddressModeClampToEdge;
-		samplerDesc.addressModeW = DKSamplerDescriptor::AddressModeClampToEdge;
-		samplerDesc.maxAnisotropy = 16;
-
-		DKObject<DKSamplerState> sampler = device->CreateSamplerState(samplerDesc);
-
-        // create shaders
-		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));
-
-		DKObject<DKSwapChain> swapChain = queue->CreateSwapChain(window);
-
-		DKLog("VertexFunction.VertexAttributes: %d", vertShaderFunction->StageInputAttributes().Count());
-		for (int i = 0; i < vertShaderFunction->StageInputAttributes().Count(); ++i)
-		{
-			const DKShaderAttribute& attr = vertShaderFunction->StageInputAttributes().Value(i);
-			DKLog("  --> VertexAttribute[%d]: \"%ls\" (location:%u)", i, (const wchar_t*)attr.name, attr.location);
-		}
-
-
-		uint32_t vertexBufferSize = static_cast<uint32_t>(SampleMesh->GetVerticesCount()) * sizeof(SampleObjMesh::Vertex);
-		uint32_t indexBufferSize = SampleMesh->GetIndicesCount() * sizeof(uint32_t);
-
-		DKObject<DKGpuBuffer> vertexBuffer = device->CreateBuffer(vertexBufferSize, DKGpuBuffer::StorageModeShared, DKCpuCacheModeReadWrite);
-		memcpy(vertexBuffer->Contents(), SampleMesh->GetVerticesData(), vertexBufferSize);
-        vertexBuffer->Flush();
-
-		DKObject<DKGpuBuffer> indexBuffer = device->CreateBuffer(indexBufferSize, DKGpuBuffer::StorageModeShared, DKCpuCacheModeReadWrite);
-		memcpy(indexBuffer->Contents(), SampleMesh->GetIndicesData(), indexBufferSize);
-        indexBuffer->Flush();
-
-		DKRenderPipelineDescriptor pipelineDescriptor;
-        // setup shader
-		pipelineDescriptor.vertexFunction = vertShaderFunction;
-		pipelineDescriptor.fragmentFunction = fragShaderFunction;
-        // setup color-attachment render-targets
-		pipelineDescriptor.colorAttachments.Resize(1);
-		pipelineDescriptor.colorAttachments.Value(0).pixelFormat = swapChain->ColorPixelFormat();
-        pipelineDescriptor.colorAttachments.Value(0).blendState.enabled = false;
-        pipelineDescriptor.colorAttachments.Value(0).blendState.sourceRGBBlendFactor = DKBlendFactor::SourceAlpha;
-        pipelineDescriptor.colorAttachments.Value(0).blendState.destinationRGBBlendFactor = DKBlendFactor::OneMinusSourceAlpha;
-        // setup depth-stencil
-		pipelineDescriptor.depthStencilAttachmentPixelFormat = DKPixelFormat::D32Float;
-        pipelineDescriptor.depthStencilDescriptor.depthWriteEnabled = true;
-        pipelineDescriptor.depthStencilDescriptor.depthCompareFunction = DKCompareFunctionLessEqual;
-        // setup vertex buffer and attributes
-        pipelineDescriptor.vertexDescriptor.attributes = {
-			{ DKVertexFormat::Float3, offsetof(SampleObjMesh::Vertex, inPos), 0, 0 },
-            { DKVertexFormat::Float3, offsetof(SampleObjMesh::Vertex, inColor), 0, 1 },
-			{ DKVertexFormat::Float2, offsetof(SampleObjMesh::Vertex, intexCoord), 0, 2 },
-		};
-		pipelineDescriptor.vertexDescriptor.layouts = {
-			{ DKVertexStepRate::Vertex, sizeof(SampleObjMesh::Vertex), 0 },
-		};
-        // setup topology and rasterization
-		pipelineDescriptor.primitiveTopology = DKPrimitiveType::Triangle;
-		pipelineDescriptor.frontFace = DKFrontFace::CCW;
-		pipelineDescriptor.triangleFillMode = DKTriangleFillMode::Fill;
-		pipelineDescriptor.depthClipMode = DKDepthClipMode::Clip;
-		pipelineDescriptor.cullMode = DKCullMode::Back;
-		pipelineDescriptor.rasterizationEnabled = true;
-
-		DKPipelineReflection reflection;
-		DKObject<DKRenderPipelineState> pipelineState = device->CreateRenderPipeline(pipelineDescriptor, &reflection);
-		if (pipelineState)
-		{
-            PrintPipelineReflection(&reflection, DKLogCategory::Verbose);
-		}
-
-        DKShaderBindingSetLayout layout;
-        if (1)
-        {
-            DKShaderBinding bindings[2] = {
-                {
-                    0,
-                    DKShader::DescriptorTypeUniformBuffer,
-                    1,
-                    nullptr
-                },
-                {
-                    1,
-                    DKShader::DescriptorTypeTextureSampler,
-                    1,
-                    nullptr
-                },
-            };
-            layout.bindings.Add(bindings, 2);
-        }
-        DKObject<DKShaderBindingSet> bindSet = device->CreateShaderBindingSet(layout);
-
-        struct UBO
-        {
-            DKMatrix4 projectionMatrix;
-            DKMatrix4 modelMatrix;
-            DKMatrix4 viewMatrix;
-        };
-        DKObject<DKGpuBuffer> uboBuffer = device->CreateBuffer(sizeof(UBO), DKGpuBuffer::StorageModeShared, DKCpuCacheModeReadWrite);
-        UBO* ubo = nullptr;
-        if (bindSet)
-        {
-            if (uboBuffer)
-            {
-                ubo = reinterpret_cast<UBO*>(uboBuffer->Contents());
-                ubo->projectionMatrix = DKMatrix4::identity;
-                ubo->modelMatrix = DKMatrix4::identity;
-                ubo->viewMatrix = DKMatrix4::identity;
-                uboBuffer->Flush();
-
-                //DKAffineTransform3 trans;
-                //trans.Multiply(DKLinearTransform3().Scale(0.5).Rotate(DKVector3(0,1,0), DKGL_PI * 0.5));
-                //ubo.modelMatrix.Multiply(trans.Matrix4());
-
-                //memcpy(uboBuffer->Contents(), &ubo, sizeof(ubo));
-                bindSet->SetBuffer(0, uboBuffer, 0, sizeof(UBO));
-            }
-
-            bindSet->SetTexture(1, texture);
-            bindSet->SetSamplerState(1, sampler);
-        }
-
-        DKObject<DKTexture> depthBuffer = nullptr;
-
-        DKCamera camera;
-        DKVector3 cameraPosition = { 0, 5, 10 };
-        DKVector3 cameraTartget = { 0, 0, 0 };
-
-        DKAffineTransform3 tm(DKLinearTransform3().Scale(5).Rotate(DKVector3(-1,0,0), DKGL_PI * 0.5));
-
-        DKTimer timer;
-		timer.Reset();
-
-		DKLog("Render thread begin");
-		while (!runningRenderThread.CompareAndSet(0, 0))
-		{
-			DKRenderPassDescriptor rpd = swapChain->CurrentRenderPassDescriptor();
-			double t = timer.Elapsed();
-			double waveT = (cos(t) + 1.0) * 0.5;
-			rpd.colorAttachments.Value(0).clearColor = DKColor(waveT, 0.0, 0.0, 0.0);
-
-            int width = rpd.colorAttachments.Value(0).renderTarget->Width();
-            int height = rpd.colorAttachments.Value(0).renderTarget->Height();
-            if (depthBuffer)
-            {
-                if (depthBuffer->Width() !=  width ||
-                    depthBuffer->Height() != height )
-                    depthBuffer = nullptr;
-            }
-            if (depthBuffer == nullptr)
-            {
-                // create depth buffer
-                DKTextureDescriptor texDesc = {};
-                texDesc.textureType = DKTexture::Type2D;
-                texDesc.pixelFormat = DKPixelFormat::D32Float;
-                texDesc.width = width;
-                texDesc.height = height;
-                texDesc.depth = 1;
-                texDesc.mipmapLevels = 1;
-                texDesc.sampleCount = 1;
-                texDesc.arrayLength = 1;
-                texDesc.usage = DKTexture::UsageRenderTarget;
-                depthBuffer = device->CreateTexture(texDesc);
-            }
-            rpd.depthStencilAttachment.renderTarget = depthBuffer;
-            rpd.depthStencilAttachment.loadAction = DKRenderPassAttachmentDescriptor::LoadActionClear;
-            rpd.depthStencilAttachment.storeAction = DKRenderPassAttachmentDescriptor::StoreActionDontCare;
-
-			DKObject<DKCommandBuffer> buffer = queue->CreateCommandBuffer();
-			DKObject<DKRenderCommandEncoder> encoder = buffer->CreateRenderCommandEncoder(rpd);
-			if (encoder)
-			{
-                if (bindSet && ubo)
-                {
-                    camera.SetView(cameraPosition, cameraTartget - cameraPosition, DKVector3(0, 1, 0));
-                    camera.SetPerspective(DKGL_DEGREE_TO_RADIAN(90), float(width)/float(height), 1, 1000);
-
-                    ubo->projectionMatrix = camera.ProjectionMatrix();
-                    ubo->viewMatrix = camera.ViewMatrix();
-
-                    DKQuaternion quat(DKVector3(0, 1, 0), t);
-                    DKAffineTransform3 trans = tm * DKAffineTransform3(quat);
-                    ubo->modelMatrix = trans.Matrix4();
-                    uboBuffer->Flush();
-                    bindSet->SetBuffer(0, uboBuffer, 0, sizeof(UBO));
-                }
-
-				encoder->SetRenderPipelineState(pipelineState);
-				encoder->SetVertexBuffer(vertexBuffer, 0, 0);
-				encoder->SetIndexBuffer(indexBuffer, 0, DKIndexType::UInt32);
-                encoder->SetResources(0, bindSet);
-				// draw scene!
-				encoder->DrawIndexed(SampleMesh->GetIndicesCount(), 1, 0, 0, 0);
-				encoder->EndEncoding();
-				buffer->Commit();
-				swapChain->Present();
-			}
-			else
-			{
-			}
-			DKThread::Sleep(0.01);
-		}
-		DKLog("RenderThread terminating...");
-	}
-
-	void OnInitialize(void) override
-	{
-        SampleApp::OnInitialize();
-		DKLogD("%s", DKGL_FUNCTION_NAME);
-
-        // create window
-        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);
-
-        SampleMesh = DKOBJECT_NEW SampleObjMesh();
-
-		LoadMesh();
-
-		runningRenderThread = 1;
-		renderThread = DKThread::Create(DKFunction(this, &MeshDemo::RenderThread)->Invocation());
-	}
-	void OnTerminate(void) override
-	{
-		DKLogD("%s", DKGL_FUNCTION_NAME);
-
-		runningRenderThread = 0;
-		renderThread->WaitTerminate();
-		renderThread = NULL;
-        window = NULL;
-
-        SampleApp::OnTerminate();
-	}
-};
-
-
-#ifdef _WIN32
-int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
-					  _In_opt_ HINSTANCE hPrevInstance,
-					  _In_ LPWSTR    lpCmdLine,
-					  _In_ int       nCmdShow)
-#else
-int main(int argc, const char * argv[])
-#endif
-{
-    MeshDemo app;
-	DKPropertySet::SystemConfig().SetValue("AppDelegate", "AppDelegate");
-	DKPropertySet::SystemConfig().SetValue("GraphicsAPI", "Vulkan");
-	return app.Run();
-}

Samples/PBRScene/PBRScene.vcxproj

@@ -25,6 +25,8 @@
     <ClInclude Include="..\Common\Win32\stdafx.h" />
     <ClInclude Include="..\Common\Win32\targetver.h" />
     <ClInclude Include="..\Libs\tinyobjLoader\tiny_obj_loader.h" />
+    <ClInclude Include="ObjImportUtil.h" />
+    <ClInclude Include="StaticMesh.h" />
   </ItemGroup>
   <ItemGroup>
     <Image Include="..\Common\Win32\SampleApp.ico" />
@@ -36,7 +38,9 @@
   <ItemGroup>
     <ClCompile Include="..\Common\dkgl_new.cpp" />
     <ClCompile Include="..\Libs\tinyobjLoader\tiny_obj_loader.cc" />
+    <ClCompile Include="ObjImportUtil.cpp" />
     <ClCompile Include="PBRScene.cpp" />
+    <ClCompile Include="StaticMesh.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\DK\DK_static.vcxproj">

Samples/PBRScene/PBRScene.vcxproj.filters

@@ -33,6 +33,8 @@
     <ClInclude Include="..\Libs\tinyobjLoader\tiny_obj_loader.h">
       <Filter>Libs</Filter>
     </ClInclude>
+    <ClInclude Include="ObjImportUtil.h" />
+    <ClInclude Include="StaticMesh.h" />
   </ItemGroup>
   <ItemGroup>
     <Image Include="..\Common\Win32\SampleApp.ico">
@@ -57,5 +59,7 @@
     <ClCompile Include="PBRScene.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="ObjImportUtil.cpp" />
+    <ClCompile Include="StaticMesh.cpp" />
   </ItemGroup>
 </Project>

Samples/PBRScene/StaticMesh.cpp

@@ -0,0 +1,262 @@
+#include "StaticMesh.h"
+#include "ObjImportUtil.h"
+
+StaticMesh::StaticMesh()
+    : mesh(nullptr)
+{
+    memset(shaderData, 0
+        , sizeof(DKObject<DKData>) * static_cast<int>(DKShaderStage::Compute));
+}
+
+bool StaticMesh::LoadMeshResourceFromFile(DKObject<DKGraphicsDevice> inDevice
+    , DKResourcePool& inDKResourcePool, const DKString& inFileName)
+{
+    if (inDevice == nullptr)
+        return false;
+
+    if (inFileName.Length() == 0)
+        return false;
+
+    if (inFileName.HasSuffix("obj"))
+    {
+        ObjImportUtil::ObjImportedMeshData loadedData
+            = ObjImportUtil::LoadFromObjFile(inFileName, inDKResourcePool);
+
+        mesh = DKObject<DKMesh>::New();
+
+        uint32_t vertexBufferSize
+            = static_cast<uint32_t>(loadedData.vertices.Count()) * loadedData.vertexSize;
+
+        DKVertexBuffer vb = {};
+        {
+            DKObject<DKGpuBuffer> vertexBuffer
+                = inDevice->CreateBuffer(vertexBufferSize, DKGpuBuffer::StorageModeShared, DKCpuCacheModeReadWrite);
+            memcpy(vertexBuffer->Contents(), loadedData.vertices, vertexBufferSize);
+            vertexBuffer->Flush();
+
+            vb.buffer = vertexBuffer;
+            vb.count = loadedData.vertices.Count();
+            vb.offset = 0;
+            vb.size = loadedData.vertexSize;
+            vb.declarations =
+            {
+                {DKVertexStream::Position, DKVertexFormat::Float3, false, offsetof(ObjImportUtil::ObjVertex, inPos), DKString("Position")},
+                {DKVertexStream::Color, DKVertexFormat::Float3, false, offsetof(ObjImportUtil::ObjVertex, inColor), DKString("Color")},
+                {DKVertexStream::Normal, DKVertexFormat::Float3, false, offsetof(ObjImportUtil::ObjVertex, inNormal), DKString("Normal")},
+                {DKVertexStream::TexCoord, DKVertexFormat::Float2, false, offsetof(ObjImportUtil::ObjVertex, inTexCoord), DKString("TexCoord")},
+            };
+
+            mesh->vertexBuffers.Add(vb);
+        }
+
+        DKSubMesh subMesh = {};
+        {
+            uint32_t indexBufferSize
+                = loadedData.indices.Count() * sizeof(uint32_t);
+
+            DKObject<DKGpuBuffer> indexBuffer =
+                inDevice->CreateBuffer(indexBufferSize
+                    , DKGpuBuffer::StorageModeShared, DKCpuCacheModeReadWrite);
+
+            memcpy(indexBuffer->Contents(), loadedData.indices, indexBufferSize);
+            indexBuffer->Flush();
+
+            subMesh.indexBuffer = indexBuffer;
+            subMesh.indexCount = loadedData.indices.Count();
+            subMesh.indexOffset = 0;
+            subMesh.indexType = DKIndexType::UInt32;
+            subMesh.vertexOffset = 0;
+            subMesh.visible = true;
+        }
+
+        mesh->subMeshes.Add(subMesh);
+
+        aabb = loadedData.aabb;
+
+        return true;
+    }
+
+    return false;
+}
+
+bool StaticMesh::LoadTextureFromFile(DKResourcePool& inDKResourcePool
+    , const DKString& inFileName)
+{
+   textureSrc = DKImage::Create(inDKResourcePool.LoadResourceData(inFileName));
+   if (textureSrc)
+       return true;
+
+   return false;
+}
+
+bool StaticMesh::LoadRenderResourceTexture(DKObject<DKCommandQueue> queue)
+{
+    if (textureSrc && texture == nullptr)
+    {
+        DKGraphicsDevice* device = queue->Device();
+        DKTextureDescriptor texDesc = {};
+        texDesc.textureType = DKTexture::Type2D;
+        texDesc.pixelFormat = DKPixelFormat::RGBA8Unorm;
+        texDesc.width = textureSrc->Width();
+        texDesc.height = textureSrc->Height();
+        texDesc.depth = 1;
+        texDesc.mipmapLevels = 1;
+        texDesc.sampleCount = 1;
+        texDesc.arrayLength = 1;
+        texDesc.usage = DKTexture::UsageCopyDestination | DKTexture::UsageSampled;
+        DKObject<DKTexture> tex = device->CreateTexture(texDesc);
+        if (tex)
+        {
+            size_t bytesPerPixel = textureSrc->BytesPerPixel();
+            DKASSERT_DESC(bytesPerPixel
+                == DKPixelFormatBytesPerPixel(texDesc.pixelFormat)
+                , "BytesPerPixel mismatch!");
+
+            uint32_t width = textureSrc->Width();
+            uint32_t height = textureSrc->Height();
+
+            size_t bufferLength = bytesPerPixel * texDesc.width * texDesc.height;
+            DKObject<DKGpuBuffer> stagingBuffer = device->CreateBuffer(bufferLength
+                , DKGpuBuffer::StorageModeShared, DKCpuCacheModeReadWrite);
+
+            memcpy(stagingBuffer->Contents(), textureSrc->Contents(), bufferLength);
+            stagingBuffer->Flush();
+
+            DKObject<DKCommandBuffer> cb = queue->CreateCommandBuffer();
+            DKObject<DKCopyCommandEncoder> encoder = cb->CreateCopyCommandEncoder();
+            encoder->CopyFromBufferToTexture(stagingBuffer,
+                { 0, width, height },
+                tex,
+                { 0,0, 0,0,0 },
+                { width,height,1 });
+            encoder->EndEncoding();
+            cb->Commit();
+
+            DKLog("Texture created!");
+            texture = tex;
+
+            // create sampler
+            DKSamplerDescriptor samplerDesc = {};
+            samplerDesc.magFilter = DKSamplerDescriptor::MinMagFilterLinear;
+            samplerDesc.minFilter = DKSamplerDescriptor::MinMagFilterLinear;
+            samplerDesc.addressModeU = DKSamplerDescriptor::AddressModeClampToEdge;
+            samplerDesc.addressModeV = DKSamplerDescriptor::AddressModeClampToEdge;
+            samplerDesc.addressModeW = DKSamplerDescriptor::AddressModeClampToEdge;
+            samplerDesc.maxAnisotropy = 16;
+
+            textureSampler = device->CreateSamplerState(samplerDesc);
+
+            return true;
+        }
+    }
+    return false;
+}
+
+bool StaticMesh::LoadShaderFromFile(DKResourcePool& inDKResourcePool
+    , const DKString& inFileName
+    , DKShaderStage inStage)
+{
+    DKObject<DKData> data = inDKResourcePool.LoadResourceData(inFileName);
+    shaderData[static_cast<int>(inStage)] = data;
+    if (data)
+        return true;
+    return false;
+}
+
+bool StaticMesh::LoadRenderResourceShader(DKObject<DKGraphicsDevice> inDevice
+    , DKShaderStage inStage)
+{
+    DKShader shader(shaderData[static_cast<int>(inStage)]);
+    DKObject<DKShaderModule> module = inDevice->CreateShaderModule(&shader);
+    DKObject<DKShaderFunction> function
+        = module->CreateFunction(module->FunctionNames().Value(0));
+    shaderModule[static_cast<int>(inStage)] = module;
+    shaderFunction[static_cast<int>(inStage)] = function;
+
+    if (module && function)
+    {
+        if (inStage == DKShaderStage::Vertex)
+        {
+            DKLog("VertexFunction.VertexAttributes: %d", function->StageInputAttributes().Count());
+            for (int i = 0; i < function->StageInputAttributes().Count(); ++i)
+            {
+                const DKShaderAttribute& attr = function->StageInputAttributes().Value(i);
+                DKLog("  --> VertexAttribute[%d]: \"%ls\" (location:%u)", i, (const wchar_t*)attr.name, attr.location);
+            }
+        }
+        return true;
+    }
+
+    return false;
+}
+
+void StaticMesh::SetupPipelineDecriptor(DKRenderPipelineDescriptor& pipelineDescriptor)
+{
+    // setup shader
+    pipelineDescriptor.vertexFunction = shaderFunction[static_cast<int>(DKShaderStage::Vertex)];
+    pipelineDescriptor.fragmentFunction = shaderFunction[static_cast<int>(DKShaderStage::Fragment)];
+
+    uint32_t i = 0;
+    for (auto decl : mesh->vertexBuffers[0].declarations)
+    {
+        pipelineDescriptor.vertexDescriptor.attributes.Add(
+            DKVertexAttributeDescriptor{ decl.format, decl.offset, 0, i }
+        );
+        i++;
+    }
+
+    pipelineDescriptor.vertexDescriptor.layouts = {
+        { DKVertexStepRate::Vertex, mesh->vertexBuffers[0].size, 0 },
+    };
+}
+
+void StaticMesh::SetupMaterial(DKObject<DKGraphicsDevice> inDevice)
+{
+    DKShaderBindingSetLayout layout;
+    if (1)
+    {
+        DKShaderBinding bindings[2] = {
+            {
+                0,
+                DKShader::DescriptorTypeUniformBuffer,
+                1,
+                nullptr
+            }, // Scene Uniform Buffer
+            {
+                1,
+                DKShader::DescriptorTypeTextureSampler,
+                1,
+                nullptr
+            }, // Texture
+        };
+        layout.bindings.Add(bindings, 2);
+    }
+
+    bindSet = inDevice->CreateShaderBindingSet(layout);
+
+    if (bindSet == nullptr)
+        return;
+
+    bindSet->SetTexture(1, texture);
+    bindSet->SetSamplerState(1, textureSampler);
+}
+
+void StaticMesh::SetupExternalUniformBuffer(DKObject<DKGpuBuffer> uniformBuffer, size_t uniformBufferSize, int index)
+{
+    if (uniformBuffer == nullptr || bindSet == nullptr)
+        return;
+
+    bindSet->SetBuffer(index, uniformBuffer, 0, uniformBufferSize);
+}
+
+bool StaticMesh::EncodeRenderCommand(DKRenderCommandEncoder* encoder) const
+{
+    encoder->SetVertexBuffer(mesh->vertexBuffers[0].buffer, 0, 0);
+    encoder->SetIndexBuffer(mesh->subMeshes[0].indexBuffer, 0, mesh->subMeshes[0].indexType);
+    encoder->SetResources(0, bindSet);
+    // draw scene!
+    encoder->DrawIndexed(mesh->subMeshes[0].indexCount, 1, 0, 0, 0);
+    encoder->EndEncoding();
+    return true;
+}
+

Samples/PBRScene/StaticMesh.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <DK.h>
+
+// simple wrapper of dk mesh
+
+class StaticMesh
+{
+public:
+    StaticMesh();
+
+    bool LoadMeshResourceFromFile(DKObject<DKGraphicsDevice> inDevice
+        , DKResourcePool& inDKResourcePool, const DKString& inFileName);
+
+    bool LoadShaderFromFile(DKResourcePool& inDKResourcePool
+        , const DKString& inFileName
+        , DKShaderStage inStage);
+
+    // Should be seperated
+    bool LoadTextureFromFile(DKResourcePool& inDKResourcePool
+        , const DKString& inFileName);
+
+    bool LoadRenderResourceTexture(DKObject<DKCommandQueue> queue);
+    bool LoadRenderResourceShader(DKObject<DKGraphicsDevice> inDevice,
+        DKShaderStage inStage);
+
+    DKObject<DKMesh> Mesh() { return mesh; }
+
+    void SetupPipelineDecriptor(DKRenderPipelineDescriptor& pipelineDescriptor);
+    void SetupMaterial(DKObject<DKGraphicsDevice> inDevice);
+    void SetupExternalUniformBuffer(DKObject<DKGpuBuffer> uniformBuffer
+        , size_t uniformBufferSize, int index);
+
+    bool EncodeRenderCommand(DKRenderCommandEncoder* encoder) const;
+
+private:
+    DKString fileName;
+    DKObject<DKMesh> mesh;
+
+    // Temporary variables before material work
+    DKObject<DKImage> textureSrc;
+
+    DKObject<DKTexture> texture;
+    DKObject<DKSamplerState> textureSampler;
+
+    DKObject<DKShaderBindingSet> bindSet;
+    DKObject<DKData> shaderData[static_cast<int>(DKShaderStage::Compute)];
+    DKObject<DKShaderModule> shaderModule[static_cast<int>(DKShaderStage::Compute)];
+    DKObject<DKShaderFunction> shaderFunction[static_cast<int>(DKShaderStage::Compute)];
+
+    DKAabb aabb;
+};