Latest chapter from vkguide but doesn't work yet.

vk_engine.cpp

@@ -1,5 +1,6 @@
 #include "vk_engine.h"
 #include "vk_images.h"
+#include "vk_pipelines.h"
 #include <print>
 
 #include <SDL.h>
@@ -15,7 +16,7 @@
 #define VMA_IMPLEMENTATION
 #include "vk_mem_alloc.h"
 
-constexpr bool bUseValidationLayers = false;
+constexpr bool bUseValidationLayers = true;
 
 VulkanEngine* loadedEngine = nullptr;
 
@@ -45,6 +46,8 @@ void VulkanEngine::init()
   init_swapchain();
   init_commands();
   init_sync_structures();
+  init_descriptors();
+  init_pipelines();
 
   //everything went fine
   _isInitialized = true;
@@ -358,11 +361,100 @@ void VulkanEngine::init_sync_structures() {
 
 void VulkanEngine::draw_background(VkCommandBuffer cmd)
 {
-  VkClearColorValue clearValue;
-  float flash = std::abs(std::sin(float(_frameNumber) / 120.0f));
-  clearValue = { { 0.0f, 0.0f, flash, 1.0f} };
+// bind the gradient drawing compute pipeline
+  vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, _gradientPipeline);
 
-  VkImageSubresourceRange clearRange = vkinit::image_subresource_range(VK_IMAGE_ASPECT_COLOR_BIT);
+  // bind the descriptor set containing the draw image for the compute pipeline
+  vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, _gradientPipelineLayout, 0, 1, &_drawImageDescriptors, 0, nullptr);
 
-  vkCmdClearColorImage(cmd, _drawImage.image, VK_IMAGE_LAYOUT_GENERAL, &clearValue, 1, &clearRange);
+  // execute the compute pipeline dispatch. We are using 16x16 workgroup size so we need to divide by it
+  vkCmdDispatch(cmd, std::ceil(_drawExtent.width / 16.0), std::ceil(_drawExtent.height / 16.0), 1);
+}
+
+
+void VulkanEngine::init_descriptors() {
+  std::vector<DescriptorAllocator::PoolSizeRatio> sizes = 
+  { 
+    { VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1 }
+  };
+
+  globalDescriptorAllocator.init_pool(_device, 10, sizes);
+
+  // make the descriptor set layout for our compute draw
+  {
+    DescriptorLayoutBuilder builder;
+    builder.add_binding(0, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE);
+    _drawImageDescriptorLayout = builder.build(_device, VK_SHADER_STAGE_COMPUTE_BIT);
+  }
+
+  // other code
+  //allocate a descriptor set for our draw image
+  _drawImageDescriptors = globalDescriptorAllocator.allocate(_device,_drawImageDescriptorLayout);	
+
+  VkDescriptorImageInfo imgInfo{};
+  imgInfo.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
+  imgInfo.imageView = _drawImage.imageView;
+
+  VkWriteDescriptorSet drawImageWrite = {};
+  drawImageWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+  drawImageWrite.pNext = nullptr;
+
+  drawImageWrite.dstBinding = 0;
+  drawImageWrite.dstSet = _drawImageDescriptors;
+  drawImageWrite.descriptorCount = 1;
+  drawImageWrite.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
+  drawImageWrite.pImageInfo = &imgInfo;
+
+  vkUpdateDescriptorSets(_device, 1, &drawImageWrite, 0, nullptr);
+
+  //make sure both the descriptor allocator and the new layout get cleaned up properly
+  _mainDeletionQueue.push_function([&]() {
+      globalDescriptorAllocator.destroy_pool(_device);
+
+      vkDestroyDescriptorSetLayout(_device, _drawImageDescriptorLayout, nullptr);
+      });
+}
+
+void VulkanEngine::init_pipelines()
+{
+  init_background_pipelines();
+}
+
+void VulkanEngine::init_background_pipelines()
+{
+  VkPipelineLayoutCreateInfo computeLayout{};
+  computeLayout.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+  computeLayout.pNext = nullptr;
+  computeLayout.pSetLayouts = &_drawImageDescriptorLayout;
+  computeLayout.setLayoutCount = 1;
+
+  VK_CHECK(vkCreatePipelineLayout(_device, &computeLayout, nullptr, &_gradientPipelineLayout));
+
+  VkShaderModule computeDrawShader;
+
+  if(!vkutil::load_shader_module("gradient.comp.spv", _device, &computeDrawShader)) {
+    std::println("Error when building compute shader");
+  }
+
+  VkPipelineShaderStageCreateInfo stageinfo{};
+  stageinfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+  stageinfo.pNext = nullptr;
+  stageinfo.stage = VK_SHADER_STAGE_COMPUTE_BIT;
+  stageinfo.module = computeDrawShader;
+  stageinfo.pName = "main";
+ 
+  VkComputePipelineCreateInfo computePipelineCreateInfo{};
+  computePipelineCreateInfo.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
+  computePipelineCreateInfo.pNext = nullptr;
+  computePipelineCreateInfo.layout = _gradientPipelineLayout;
+  computePipelineCreateInfo.stage = stageinfo;
+
+  VK_CHECK(vkCreateComputePipelines(_device,VK_NULL_HANDLE,1, &computePipelineCreateInfo, nullptr, &_gradientPipeline));
+
+  vkDestroyShaderModule(_device, computeDrawShader, nullptr);
+
+  _mainDeletionQueue.push_function([&]() {
+      vkDestroyPipelineLayout(_device, _gradientPipelineLayout, nullptr);
+      vkDestroyPipeline(_device, _gradientPipeline, nullptr);
+  });
 }