feat(ApiVk): added basic dynamic rendering support

tomezpl · tomezpl · commit 997dfef0f426 · 2025-01-16T21:48:23.000Z
diff --git a/src/lepus/gfx/GraphicsEngine/Apis/ApiVk.h b/src/lepus/gfx/GraphicsEngine/Apis/ApiVk.h
@@ -38,6 +38,12 @@ namespace lepus
 	    VkFramebuffer* m_FrameBuffers;
 	    uint32_t m_FrameBufferCount;
 	    uint32_t m_CurrentImageIndex;
+	    uint32_t m_SwapChainImageCount;
+	    VkImageView* m_ImageViews;
+	    VkImage* m_Images;
+	    VkFence m_vkFence, m_vkCmdBufFence;
+	    PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR;
+	    PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR;
 
 	    inline void* GetUniformInternal(const char* name) override
 	    {
@@ -51,13 +57,23 @@ namespace lepus
 		m_FrameBuffers = nullptr;
 		m_FrameBufferCount = 0;
 		m_CurrentImageIndex = 0;
+		m_SwapChainImageCount = 0;
+		m_ImageViews = nullptr;
+		m_Images = nullptr;
+		m_vkFence = VK_NULL_HANDLE;
+		m_vkCmdBufFence = VK_NULL_HANDLE;
 	    }
 
 	    GraphicsApiVk(GraphicsApiOptions* options)
 	    {
 		m_FrameBuffers = nullptr;
 		m_FrameBufferCount = 0;
 		m_CurrentImageIndex = 0;
+		m_SwapChainImageCount = 0;
+		m_ImageViews = nullptr;
+		m_Images = nullptr;
+		m_vkFence = VK_NULL_HANDLE;
+		m_vkCmdBufFence = VK_NULL_HANDLE;
 		GraphicsApiVk::Init(options);
 	    }
 
diff --git a/src/lepus/gfx/GraphicsEngine/Apis/ApiVk/ApiVk.cpp b/src/lepus/gfx/GraphicsEngine/Apis/ApiVk/ApiVk.cpp
@@ -30,7 +30,19 @@ void GraphicsApiVk::Init(GraphicsApiOptions* options)
         vkCreateWin32SurfaceKHR(vkbInstance.instance, &createInfo, nullptr, &_vkSurface);*/
 
     vkb::PhysicalDeviceSelector deviceSelector(vkbInstance);
-    auto physDevWrapper = deviceSelector.set_surface(m_vkSurface).set_minimum_version(1, 1).require_dedicated_transfer_queue().select();
+
+    VkPhysicalDeviceVulkan13Features features = {};
+    features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
+    features.dynamicRendering = VK_TRUE;
+    auto physDevWrapper = deviceSelector
+                              .set_surface(m_vkSurface)
+                              .set_minimum_version(1, 3)
+                              .add_required_extension(VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME)
+                              .add_required_extension(VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME)
+                              .add_required_extension(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME)
+                              .add_required_extension_features(features)
+                              .require_dedicated_transfer_queue()
+                              .select();
     assert(physDevWrapper);
     vkb::DeviceBuilder deviceBuilder(physDevWrapper.value());
     auto devWrapper = deviceBuilder.build();
@@ -43,7 +55,7 @@ void GraphicsApiVk::Init(GraphicsApiOptions* options)
     VkQueue graphicsQueue = graphicsQueueWrapper.value();
 
     vkb::SwapchainBuilder swapchainBuilder(vkbDevice);
-    auto swapchainResult = swapchainBuilder.build();
+    auto swapchainResult = swapchainBuilder.set_desired_present_mode(VK_PRESENT_MODE_FIFO_KHR).build();
     assert(swapchainResult);
 
     m_vkDevice = device;
@@ -52,7 +64,7 @@ void GraphicsApiVk::Init(GraphicsApiOptions* options)
     m_vkSwapchain = swapchainResult.value();
 
     VkCommandPoolCreateInfo cmdPoolCreateInfo;
-    cmdPoolCreateInfo.flags = 0;
+    cmdPoolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
     cmdPoolCreateInfo.pNext = 0;
     cmdPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
     cmdPoolCreateInfo.queueFamilyIndex = vkbDevice.get_queue_index(vkb::QueueType::graphics).value();
@@ -65,6 +77,43 @@ void GraphicsApiVk::Init(GraphicsApiOptions* options)
     cmdBufferAllocInfo.commandPool = m_CommandPool;
     cmdBufferAllocInfo.commandBufferCount = 1;
     assert(vkAllocateCommandBuffers(m_vkDevice, &cmdBufferAllocInfo, &m_CommandBuffer) == VK_SUCCESS);
+
+    vkGetSwapchainImagesKHR(m_vkDevice, m_vkSwapchain, &m_SwapChainImageCount, VK_NULL_HANDLE);
+    if (m_SwapChainImageCount)
+    {
+	VkImageViewUsageCreateInfo usageCreateInfo = {VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, VK_NULL_HANDLE, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT};
+	m_Images = new VkImage[m_SwapChainImageCount];
+	vkGetSwapchainImagesKHR(m_vkDevice, m_vkSwapchain, &m_SwapChainImageCount, m_Images);
+	m_ImageViews = new VkImageView[m_SwapChainImageCount];
+	VkComponentMapping componentMapping = {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY};
+	for (uint32_t i = 0; i < m_SwapChainImageCount; i++)
+	{
+	    VkImageViewCreateInfo createInfo = {};
+	    createInfo.pNext = &usageCreateInfo;
+	    createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+	    createInfo.image = m_Images[i];
+	    createInfo.flags = 0;
+	    createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+	    createInfo.format = VK_FORMAT_B8G8R8A8_SRGB;
+	    createInfo.components = componentMapping;
+	    createInfo.subresourceRange = {
+	        VK_IMAGE_ASPECT_COLOR_BIT,
+	        0,
+	        1,
+	        0,
+	        1};
+	    vkCreateImageView(m_vkDevice, &createInfo, nullptr, &m_ImageViews[i]);
+	}
+    }
+
+    VkFenceCreateInfo fenceCreateInfo = {};
+    fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+    fenceCreateInfo.flags = 0;
+
+    vkCreateFence(m_vkDevice, &fenceCreateInfo, nullptr, &m_vkFence);
+    vkCreateFence(m_vkDevice, &fenceCreateInfo, VK_NULL_HANDLE, &m_vkCmdBufFence);
+    vkCmdBeginRenderingKHR = (PFN_vkCmdBeginRenderingKHR)vkGetInstanceProcAddr(m_vkInstance, "vkCmdBeginRenderingKHR");
+    vkCmdEndRenderingKHR = (PFN_vkCmdEndRenderingKHR)vkGetInstanceProcAddr(m_vkInstance, "vkCmdEndRenderingKHR");
 }
 
 lepus::engine::objects::Mesh* GraphicsApiVk::WrapMesh(engine::objects::Mesh* mesh)
@@ -75,25 +124,32 @@ lepus::engine::objects::Mesh* GraphicsApiVk::WrapMesh(engine::objects::Mesh* mes
 
 void GraphicsApiVk::ClearFrameBuffer(float r, float g, float b)
 {
-    VkCommandBufferBeginInfo beginInfo;
+    VkCommandBufferBeginInfo beginInfo = {};
     beginInfo.pNext = 0;
     beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
     beginInfo.flags = 0;
     beginInfo.pInheritanceInfo = 0;
 
+    vkResetFences(m_vkDevice, 1, &m_vkFence);
+    vkResetFences(m_vkDevice, 1, &m_vkCmdBufFence);
     vkBeginCommandBuffer(m_CommandBuffer, &beginInfo);
+
+    vkAcquireNextImageKHR(m_vkDevice, m_vkSwapchain, UINT64_MAX, nullptr, m_vkFence, &m_CurrentImageIndex);
+    vkWaitForFences(m_vkDevice, 1, &m_vkFence, VK_TRUE, UINT64_MAX);
+
     VkImageSubresourceRange ranges;
     ranges.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
     ranges.layerCount = 1;
     ranges.levelCount = 1;
     ranges.baseArrayLayer = 0;
     ranges.baseMipLevel = 0;
-    VkClearColorValue colour;
+    VkClearColorValue colour = {};
     const float gamma = 2.2f;
+    // const float gamma = 1.f / 2.2f;
     colour.float32[0] = powf(r, gamma);
     colour.float32[1] = powf(g, gamma);
     colour.float32[2] = powf(b, gamma);
-    colour.float32[3] = 1.f;
+    colour.float32[3] = 0.f;
     // colour.int32[0] = 100;
     // colour.int32[1] = 149;
     // colour.int32[2] = 237;
@@ -103,7 +159,7 @@ void GraphicsApiVk::ClearFrameBuffer(float r, float g, float b)
     // colour.uint32[2] = 237;
     // colour.uint32[3] = 255;
     uint32_t swapchainImageCount = 0;
-    vkGetSwapchainImagesKHR(m_vkDevice, m_vkSwapchain, &swapchainImageCount, nullptr);
+    // vkGetSwapchainImagesKHR(m_vkDevice, m_vkSwapchain, &swapchainImageCount, nullptr);
     if (swapchainImageCount > 0)
     {
 	VkImage* swapchainImages = new VkImage[swapchainImageCount];
@@ -112,14 +168,90 @@ void GraphicsApiVk::ClearFrameBuffer(float r, float g, float b)
 	for (uint32_t i = 0; i < swapchainImageCount; i++)
 	{
 
-	    vkCmdClearColorImage(m_CommandBuffer, swapchainImages[i], VK_IMAGE_LAYOUT_GENERAL, &colour, 1, &ranges);
+	    // vkCmdClearColorImage(m_CommandBuffer, swapchainImages[i], VK_IMAGE_LAYOUT_GENERAL, &colour, 1, &ranges);
 	}
 
 	// delete[] swapchainImages;
     }
+
+    VkRenderingAttachmentInfo colourAttachment = {};
+    colourAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
+    colourAttachment.clearValue = {};
+    colourAttachment.clearValue.depthStencil = {};
+    colourAttachment.clearValue.color = colour;
+    colourAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+    colourAttachment.resolveMode = VK_RESOLVE_MODE_NONE;
+    colourAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+    colourAttachment.imageView = m_ImageViews[m_CurrentImageIndex];
+    colourAttachment.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
+
+    VkRenderingInfo renderingInfo = {};
+    renderingInfo.pNext = VK_NULL_HANDLE;
+    renderingInfo.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
+    renderingInfo.layerCount = 1;
+    renderingInfo.viewMask = 0;
+    renderingInfo.colorAttachmentCount = 1;
+    renderingInfo.pColorAttachments = &colourAttachment;
+    VkRenderingAttachmentInfo depthAttachment = {};
+    depthAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
+    depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+    depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+    depthAttachment.imageView = VK_NULL_HANDLE;
+    depthAttachment.resolveMode = VK_RESOLVE_MODE_NONE;
+    VkRenderingAttachmentInfo stencilAttachment = {};
+    stencilAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
+    stencilAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+    stencilAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+    stencilAttachment.imageView = VK_NULL_HANDLE;
+    stencilAttachment.resolveMode = VK_RESOLVE_MODE_NONE;
+    // renderingInfo.pDepthAttachment = &depthAttachment;
+    // renderingInfo.pStencilAttachment = &stencilAttachment;
+    VkRect2D renderArea = {};
+    renderArea.offset = {0, 0};
+    renderArea.extent = {800, 600};
+    renderingInfo.renderArea = renderArea;
+
+    VkImageMemoryBarrier imgMemBarrier = {
+        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+        VK_NULL_HANDLE,
+        VK_ACCESS_NONE,
+        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+        VK_IMAGE_LAYOUT_UNDEFINED,
+        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+        0,
+        0,
+        m_Images[m_CurrentImageIndex],
+        {VK_IMAGE_ASPECT_COLOR_BIT,
+         0,
+         1,
+         0,
+         1}};
+
+    vkCmdPipelineBarrier(m_CommandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, nullptr, 0, nullptr, 1, &imgMemBarrier);
+
+    vkCmdBeginRenderingKHR(m_CommandBuffer, &renderingInfo);
+    vkCmdEndRenderingKHR(m_CommandBuffer);
+
+    imgMemBarrier = {
+        VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
+        VK_NULL_HANDLE,
+        VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
+        VK_ACCESS_NONE,
+        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
+        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
+        0,
+        0,
+        m_Images[m_CurrentImageIndex],
+        {VK_IMAGE_ASPECT_COLOR_BIT,
+         0,
+         1,
+         0,
+         1}};
+
+    vkCmdPipelineBarrier(m_CommandBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &imgMemBarrier);
+
     vkEndCommandBuffer(m_CommandBuffer);
 
-    vkAcquireNextImageKHR(m_vkDevice, m_vkSwapchain, UINT64_MAX, nullptr, nullptr, &m_CurrentImageIndex);
     // assert(acquireResult == VK_SUCCESS);
 
     VkSubmitInfo submitInfo;
@@ -132,7 +264,8 @@ void GraphicsApiVk::ClearFrameBuffer(float r, float g, float b)
     submitInfo.signalSemaphoreCount = 0;
     submitInfo.waitSemaphoreCount = 0;
     submitInfo.pWaitDstStageMask = 0;
-    vkQueueSubmit(m_vkQueue, 1, &submitInfo, nullptr);
+    vkQueueSubmit(m_vkQueue, 1, &submitInfo, m_vkCmdBufFence);
+    vkWaitForFences(m_vkDevice, 1, &m_vkCmdBufFence, VK_TRUE, UINT64_MAX);
 }
 
 void GraphicsApiVk::SwapBuffers()
@@ -153,6 +286,12 @@ void GraphicsApiVk::SwapBuffers()
 
 void GraphicsApiVk::Shutdown()
 {
+    vkDestroyFence(m_vkDevice, m_vkFence, VK_NULL_HANDLE);
+    for (uint32_t i = 0; i < m_SwapChainImageCount; i++)
+    {
+	vkDestroyImageView(m_vkDevice, m_ImageViews[i], VK_NULL_HANDLE);
+    }
+
     vkDestroyCommandPool(m_vkDevice, m_CommandPool, nullptr);
     vkDestroySwapchainKHR(m_vkDevice, m_vkSwapchain, nullptr);
     vkDestroyDevice(m_vkDevice, nullptr);
