fix : respacing

Samples/DKGLDemoScene/DKGLDemoScene.cpp

 class DKGLDemo : public SampleApp
 {
     DKObject<DKWindow> window;
-	DKObject<DKThread> renderThread;
-	DKAtomicNumber32 runningRenderThread;
-	DKObject<StaticMesh> sampleMesh;
+    DKObject<DKThread> renderThread;
+    DKAtomicNumber32 runningRenderThread;
+    DKObject<StaticMesh> sampleMesh;
 
     DKObject<DKGpuBuffer> sceneUniformBuffer;
     SceneUniformBuffer* sceneBufferData = nullptr;
         sampleMesh->LoadTextureFromFile(resourcePool, texturePath);
     }
 
-	void LoadRenderResource(DKObject<DKCommandQueue> queue)
-	{
-		DKLog("Loading Static Meshes");
+    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->EncodeRenderCommand(encoder);
     }
 
-	void RenderThread(void)
-	{
-		DKObject<DKGraphicsDevice> device = DKGraphicsDevice::SharedInstance();
+    void RenderThread(void)
+    {
+        DKObject<DKGraphicsDevice> device = DKGraphicsDevice::SharedInstance();
         DKObject<DKCommandQueue> queue = device->CreateCommandQueue(DKCommandQueue::Graphics);
 
         LoadRenderResource(queue);
 
-		DKObject<DKSwapChain> swapChain = queue->CreateSwapChain(window);
+        DKObject<DKSwapChain> swapChain = queue->CreateSwapChain(window);
 
-		DKRenderPipelineDescriptor pipelineDescriptor;
+        DKRenderPipelineDescriptor pipelineDescriptor;
         // setup color-attachment render-targets
         pipelineDescriptor.colorAttachments.Resize(1);
         pipelineDescriptor.colorAttachments.Value(0).pixelFormat = swapChain->ColorPixelFormat();
 
         SetupPipeline(pipelineDescriptor);
 
-		DKPipelineReflection reflection;
-		DKObject<DKRenderPipelineState> pipelineState = device->CreateRenderPipeline(pipelineDescriptor, &reflection);
-		if (pipelineState)
-		{
+        DKPipelineReflection reflection;
+        DKObject<DKRenderPipelineState> pipelineState = device->CreateRenderPipeline(pipelineDescriptor, &reflection);
+        if (pipelineState)
+        {
             PrintPipelineReflection(&reflection, DKLogCategory::Verbose);
-		}
+        }
 
         SetupMaterial(device);
         SetupSceneUniformBuffer(device);
         DKVector3 cameraPosition = { 0, 5, 10 };
         DKVector3 cameraTartget = { 0, 0, 0 };
 
-        DKAffineTransform3 tm(DKLinearTransform3().Scale(5).Rotate(DKVector3(-1,0,0), DKGL_PI * 0.5));
+        DKAffineTransform3 tm(DKLinearTransform3().Scale(5).Rotate(DKVector3(-1, 0, 0), DKGL_PI * 0.5));
 
         DKTimer timer;
-		timer.Reset();
+        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);
+        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 )
+                if (depthBuffer->Width() != width ||
+                    depthBuffer->Height() != height)
                     depthBuffer = nullptr;
             }
             if (depthBuffer == nullptr)
             rpd.depthStencilAttachment.loadAction = DKRenderPassAttachmentDescriptor::LoadActionClear;
             rpd.depthStencilAttachment.storeAction = DKRenderPassAttachmentDescriptor::StoreActionDontCare;
 
-			DKObject<DKCommandBuffer> buffer = queue->CreateCommandBuffer();
-			DKObject<DKRenderCommandEncoder> encoder = buffer->CreateRenderCommandEncoder(rpd);
-			if (encoder)
-			{
+            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);
+                    camera.SetPerspective(DKGL_DEGREE_TO_RADIAN(90), float(width) / float(height), 1, 1000);
 
                     sceneBufferData->projectionMatrix = camera.ProjectionMatrix();
                     sceneBufferData->viewMatrix = camera.ViewMatrix();
                     sampleMesh->SetupExternalUniformBuffer(sceneUniformBuffer, sizeof(SceneUniformBuffer), 0);
                 }
 
-				encoder->SetRenderPipelineState(pipelineState);
+                encoder->SetRenderPipelineState(pipelineState);
 
                 EncodeScene(encoder);
 
                 buffer->Commit();
-				swapChain->Present();
-			}
-			else
-			{
-			}
-			DKThread::Sleep(0.01);
-		}
-		DKLog("RenderThread terminating...");
-	}
-
-	void OnInitialize(void) override
-	{
+                swapChain->Present();
+            }
+            else
+            {
+            }
+            DKThread::Sleep(0.01);
+        }
+        DKLog("RenderThread terminating...");
+    }
+
+    void OnInitialize(void) override
+    {
         SampleApp::OnInitialize();
-		DKLogD("%s", DKGL_FUNCTION_NAME);
+        DKLogD("%s", DKGL_FUNCTION_NAME);
 
         // create window
         window = DKWindow::Create("DefaultWindow");
         window->Activate();
 
         window->AddEventHandler(this, DKFunction([this](const DKWindow::WindowEvent& e)
-        {
-            if (e.type == DKWindow::WindowEvent::WindowClosed)
-                DKApplication::Instance()->Terminate(0);
-        }), NULL, NULL);
+            {
+                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 = 1;
+        renderThread = DKThread::Create(DKFunction(this, &DKGLDemo::RenderThread)->Invocation());
+    }
+    void OnTerminate(void) override
+    {
+        DKLogD("%s", DKGL_FUNCTION_NAME);
 
-		runningRenderThread = 0;
-		renderThread->WaitTerminate();
-		renderThread = NULL;
+        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)
+    _In_opt_ HINSTANCE hPrevInstance,
+    _In_ LPWSTR    lpCmdLine,
+    _In_ int       nCmdShow)
 #else
-int main(int argc, const char * argv[])
+int main(int argc, const char* argv[])
 #endif
 {
     DKGLDemo app;
-	DKPropertySet::SystemConfig().SetValue("AppDelegate", "AppDelegate");
-	DKPropertySet::SystemConfig().SetValue("GraphicsAPI", "Vulkan");
-	return app.Run();
+    DKPropertySet::SystemConfig().SetValue("AppDelegate", "AppDelegate");
+    DKPropertySet::SystemConfig().SetValue("GraphicsAPI", "Vulkan");
+    return app.Run();
 }