ComputeShader 리소스 추가 (1024x1024 텍스쳐)

ComputeShader ThreadingGroup 적용.

Samples/ComputeShader/ComputeShader.cpp

 
     DKArray<UVQuad::Vertex> vertices =
     {
-        { { 1.0f, 1.0f, 0.0f }, { 1.0f, 0.0f } },
-        { { -1.0f, 1.0f, 0.0f }, { 0.0f, 0.0f } },
+        { {  1.0f,  1.0f, 0.0f }, { 1.0f, 0.0f } },
+        { { -1.0f,  1.0f, 0.0f }, { 0.0f, 0.0f } },
         { { -1.0f, -1.0f, 0.0f }, { 0.0f, 1.0f } },
-        { { 1.0f, -1.0f, 0.0f }, { 1.0f, 1.0f } }
+        { {  1.0f, -1.0f, 0.0f }, { 1.0f, 1.0f } }
     };
 
     DKArray<uint32_t> indices = { 0,1,2,2,3,0 };
     }
 };
 
-class TextureComputeTarget
-{
-private:
-    DKObject<DKTexture> textureTarget = nullptr;
-
-public:
-    TextureComputeTarget() = default;
-
-    DKTexture* ComputeTarget(DKCommandQueue* queue, int w, int h)
-    {
-        auto device = queue->Device();
-
-        if (textureTarget)
-        {
-            if (textureTarget->Width() != w ||
-                textureTarget->Height() != h)
-                textureTarget = nullptr;
-        }
-
-        if (textureTarget == nullptr)
-        {
-            DKTextureDescriptor texDesc = {};
-            texDesc.textureType = DKTexture::Type2D;
-            texDesc.pixelFormat = DKPixelFormat::BGRA8Unorm;
-            texDesc.width = w;
-            texDesc.height = h;
-            texDesc.depth = 1;
-            texDesc.mipmapLevels = 1;
-            texDesc.sampleCount = 1;
-            texDesc.arrayLength = 1;
-            texDesc.usage = DKTexture::UsageStorage  // For Compute Shader
-                | DKTexture::UsageSampled | DKTexture::UsageShaderRead;// For FragmentShader
-            textureTarget = device->CreateTexture(texDesc);
-        }
-
-        return textureTarget;
-    }
-};
-
 class GPUShader
 {
 private:
     DKObject<DKShaderModule> shaderModule = nullptr;
     DKObject<DKShaderFunction> shaderFunc = nullptr;
 public:
-    GPUShader(DKData* data) : shaderData(data)
+
+    struct { uint32_t x, y, z; } threadgroupSize;
+
+    GPUShader(DKData* data) : shaderData(data), threadgroupSize{1,1,1}
     {
     }
 
             DKShader shader(shaderData);
             shaderModule = device->CreateShaderModule(&shader);
             shaderFunc = shaderModule->CreateFunction(shaderModule->FunctionNames().Value(0));
+            if (shaderFunc)
+            {
+                threadgroupSize = { shader.ThreadgroupSize().x,
+                                    shader.ThreadgroupSize().y,
+                                    shader.ThreadgroupSize().z };
+            }
         }
     }
 
 	DKObject<UVQuad> quad;
     DKObject<DKTexture> textureColorMap;
 
-    DKObject<TextureComputeTarget> computeTarget;
     DKObject<DKSamplerState> sampleState = nullptr;;
 
     DKObject<GraphicShaderBindingSet> graphicShaderBindingSet = nullptr;
     {
         // Device and Queue Preperation
         DKObject<DKGraphicsDevice> device = DKGraphicsDevice::SharedInstance();
-        DKObject<DKCommandQueue> graphicsQueue = device->CreateCommandQueue(DKCommandQueue::Graphics);
-        DKObject<DKCommandQueue> computeQueue = device->CreateCommandQueue(DKCommandQueue::Compute);
+        DKObject<DKCommandQueue> graphicsQueue = device->CreateCommandQueue(DKCommandQueue::Graphics| DKCommandQueue::Compute);
+        //DKObject<DKCommandQueue> computeQueue = device->CreateCommandQueue(DKCommandQueue::Compute);
+        DKObject<DKCommandQueue> computeQueue = graphicsQueue;
 
         // Geometry Initialzie
         quad->InitializeGpuResource(graphicsQueue);
         auto cs_shf = cs_sh->Function();
 
         // Texture Resource Initialize
-        
-        computeTarget = DKOBJECT_NEW TextureComputeTarget();
-        
-        DKSamplerDescriptor computeSamplerDesc = {};
-        computeSamplerDesc.magFilter = DKSamplerDescriptor::MinMagFilterLinear;
-        computeSamplerDesc.minFilter = DKSamplerDescriptor::MinMagFilterLinear;
-        computeSamplerDesc.mipFilter = DKSamplerDescriptor::MipFilterLinear;
-        computeSamplerDesc.addressModeU = DKSamplerDescriptor::AddressModeClampToEdge;
-        computeSamplerDesc.addressModeV = DKSamplerDescriptor::AddressModeClampToEdge;
-        computeSamplerDesc.addressModeW = DKSamplerDescriptor::AddressModeClampToEdge;
-        computeSamplerDesc.maxAnisotropy = 1.0f;
-        computeSamplerDesc.compareFunction = DKCompareFunctionNever;
-        DKObject<DKSamplerState> computeSampler = device->CreateSamplerState(computeSamplerDesc);
-
-        // create texture
-		DKObject<DKTexture> texture = LoadTexture2D(graphicsQueue, resourcePool.LoadResourceData("textures/deathstar3.png"));
+		DKObject<DKTexture> sourceTexture = LoadTexture2D(graphicsQueue, resourcePool.LoadResourceData("textures/Vulkan_1024.png"));
+        DKObject<DKTexture> targetTexture = [](DKGraphicsDevice* device, int width, int height) {
+            DKTextureDescriptor texDesc = {};
+            texDesc.textureType = DKTexture::Type2D;
+            texDesc.pixelFormat = DKPixelFormat::BGRA8Unorm;
+            texDesc.width = width;
+            texDesc.height = height;
+            texDesc.depth = 1;
+            texDesc.mipmapLevels = 1;
+            texDesc.sampleCount = 1;
+            texDesc.arrayLength = 1;
+            texDesc.usage = DKTexture::UsageStorage |   // For Compute Shader
+                            DKTexture::UsageSampled;    // For FragmentShader
+            return device->CreateTexture(texDesc);
+        }(graphicsQueue->Device(), sourceTexture->Width(), sourceTexture->Height());
 		
-        // create sampler
+        // create sampler for fragment-shader
 		DKSamplerDescriptor samplerDesc = {};
 		samplerDesc.magFilter = DKSamplerDescriptor::MinMagFilterLinear;
 		samplerDesc.minFilter = DKSamplerDescriptor::MinMagFilterLinear;
 
         DKComputePipelineDescriptor embossComputePipelineDescriptor;
         embossComputePipelineDescriptor.computeFunction = cs_ef;
-        auto emboss = device->CreateComputePipeline(embossComputePipelineDescriptor);
+        DKObject<DKComputePipelineState> emboss = device->CreateComputePipeline(embossComputePipelineDescriptor);
         
         DKObject<DKTexture> depthBuffer = nullptr;
-        DKObject<DKTexture> targettex = nullptr;
-
+      
         DKTimer timer;
 		timer.Reset();
 
             rpd.depthStencilAttachment.loadAction = DKRenderPassAttachmentDescriptor::LoadActionClear;
             rpd.depthStencilAttachment.storeAction = DKRenderPassAttachmentDescriptor::StoreActionDontCare;
 
-            targettex = computeTarget->ComputeTarget(computeQueue, width, height);
-
             DKObject<DKCommandBuffer> computeCmdbuffer = computeQueue->CreateCommandBuffer();
             DKObject<DKComputeCommandEncoder> computeEncoder = computeCmdbuffer->CreateComputeCommandEncoder();
             if (computeEncoder)
             {
                 if (computebindSet)
                 {
-                    computebindSet->SetTexture(0, texture);
-                    computebindSet->SetTexture(1, targettex);
+                    computebindSet->SetTexture(0, sourceTexture);
+                    computebindSet->SetTexture(1, targetTexture);
                 }
                 computeEncoder->SetComputePipelineState(emboss);
                 computeEncoder->SetResources(0, computebindSet);
-                computeEncoder->Dispatch(width / 16, height / 16, 1);
+                computeEncoder->Dispatch(targetTexture->Width() / cs_e->threadgroupSize.x,
+                                         targetTexture->Height() / cs_e->threadgroupSize.y,
+                                         1);
                 computeEncoder->EndEncoding();
             }
 
                 if (graphicShaderBindingSet->PostcomputeDescSet() && ubo)
                 {
                     graphicShaderBindingSet->PostcomputeDescSet()->SetBuffer(0, uboBuffer, 0, sizeof(GraphicShaderBindingSet::UBO));
-                    graphicShaderBindingSet->PostcomputeDescSet()->SetTexture(1, targettex);
+                    graphicShaderBindingSet->PostcomputeDescSet()->SetTexture(1, targetTexture);
                     graphicShaderBindingSet->PostcomputeDescSet()->SetSamplerState(1, sampler);
                 }
 
         // create window
         window = DKWindow::Create("DefaultWindow");
         window->SetOrigin({ 0, 0 });
-        window->Resize({ 320, 240 });
+        window->Resize({ 512, 512 });
         window->Activate();
 
         window->AddEventHandler(this, DKFunction([this](const DKWindow::WindowEvent& e)

Samples/Data/textures/Vulkan_1024.png (Stored with Git LFS)

+oid sha256:ea36d4110bfa06f6e30af833e2c5047b937aa0471a5bfb0fd19ed9013dd85b2f
+size 495747