Вывод кадра на экран

include/vk.h

@@ -13,6 +13,7 @@ class Vulkan
     public:
         void init(GLFWwindow* window); // инициализация 
         void destroy(); // завершение работы
+        void renderFrame(); // рендер кадра
     private:
         VkInstance instance; // Экземпляр Vulkan
         PhysicalDevice physicalDevice; // Физическое устройство
@@ -22,6 +23,7 @@ class Vulkan
         VkSwapchainKHR swapChain; // Список показа
         std::vector<VkImage> swapChainImages; // Изображения из списка показа
         std::vector<VkImageView> swapChainImageViews; // Информация об изображениях из списка показа
+        std::vector<VkFramebuffer> swapChainFramebuffers; // Буферы кадра из списка показа
         VkRenderPass renderPass; // Проходы рендера
         VkPipelineLayout pipelineLayout; // Раскладка конвейера
         VkPipeline graphicsPipeline; // Графический конвейер
@@ -34,6 +36,7 @@ class Vulkan
         std::vector<VkSemaphore> imageAvailableSemaphores; // семафор доступности изображения
         std::vector<VkSemaphore> renderFinishedSemaphores; // семафор окончания рендера
         std::vector<VkFence> inWorkFences; // барьер кадра в работе
+        uint32_t currentFrame = 0; // Текущий кадр рендера
 
         // Структура для хранения флагов
         struct 
@@ -57,6 +60,7 @@ class Vulkan
         void createVertexBuffer(); // Создание буфера вершин
         void createIndexBuffer(); // Создание буфера индексов
         void createSyncObjects(); // Создание объектов синхронизации
+        void createFramebuffers(); // Создание буферов кадра
 };  
 
 #endif // VK_H

src/main.cpp

@@ -30,6 +30,7 @@ int main(int argc, char* argv[]) {
         while(!glfwWindowShouldClose(window)) {
             // Обработка событий
             glfwPollEvents();
+            vulkan.renderFrame();
         }
 
         // Уничтожение окна

src/vk.cpp

@@ -18,6 +18,7 @@ void Vulkan::init(GLFWwindow* window)
     createLogicalDevice(deviceExtensions); // Создание физического устройства
     createSwapchain(window); // Создание списка показа
     createRenderpass(); // Создание проходов рендера
+    createFramebuffers(); // Создание буферов кадра
     createGraphicPipeline(); // Создание графического конвейера
     createCommandPool(); // Создание пула команд
     createVertexBuffer(); // Создание буфера вершин
@@ -46,6 +47,12 @@ void Vulkan::destroy()
 
     vkDestroyCommandPool(logicalDevice, commandPool, nullptr); // Уничтожение командного пула
     
+    // Уничтожение буферов кадра
+    for (auto framebuffer : swapChainFramebuffers) 
+    {
+        vkDestroyFramebuffer(logicalDevice, framebuffer, nullptr);
+    }
+
     vkDestroyPipeline(logicalDevice, graphicsPipeline, nullptr); // Уничтожение графического конвейера
     vkDestroyPipelineLayout(logicalDevice, pipelineLayout, nullptr); // Уничтожение раскладки графического конвейера
     vkDestroyRenderPass(logicalDevice, renderPass, nullptr); // Уничтожение проходов рендера
@@ -957,3 +964,118 @@ void Vulkan::createSyncObjects()
     }
 }
 
+// Создание буферов кадра
+void Vulkan::createFramebuffers() 
+{
+    // Зададим размер массива в соответствии с количеством изображений
+    swapChainFramebuffers.resize(swapChainImageViews.size());
+    // Для каждого изображения из списка показа
+    for (int i = 0; i < swapChainImageViews.size(); i++) 
+    {
+        // Изображения используемые в буфере кадра
+        VkImageView attachments[] = { swapChainImageViews[i] };
+        // Заполним данные о создаваемом буфере кадра 
+        VkFramebufferCreateInfo framebufferInfo{};
+        framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+        framebufferInfo.renderPass = renderPass;
+        framebufferInfo.attachmentCount = 1;
+        framebufferInfo.pAttachments = attachments;
+        framebufferInfo.width = surface.selectedExtent.width;
+        framebufferInfo.height = surface.selectedExtent.height;
+        framebufferInfo.layers = 1;
+
+        // Создание буфера кадра
+        if (vkCreateFramebuffer(logicalDevice, &framebufferInfo, nullptr, &swapChainFramebuffers[i]) != VK_SUCCESS) 
+        {
+            throw std::runtime_error("Unable to create framebuffer");
+        }
+    }
+}
+
+// Рендер кадра
+void Vulkan::renderFrame() 
+{
+    vkWaitForFences(logicalDevice, 1, &inWorkFences[currentFrame], VK_TRUE, UINT64_MAX);
+    vkResetFences(logicalDevice, 1, &inWorkFences[currentFrame]);
+
+    uint32_t imageIndex;
+    VkResult result = vkAcquireNextImageKHR(logicalDevice, swapChain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
+
+    if (result != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to acquire swap chain image");
+    }
+
+    vkResetCommandBuffer(commandBuffers[currentFrame], 0);
+    VkCommandBufferBeginInfo beginInfo{};
+    beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+
+    if (vkBeginCommandBuffer(commandBuffers[currentFrame], &beginInfo) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to begin recording command buffer");
+    }
+
+    VkClearValue clearColor = {0.0f, 0.0f, 0.0f, 1.0f};
+
+    VkRenderPassBeginInfo renderPassInfo{};
+    renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+    renderPassInfo.renderPass = renderPass;
+    renderPassInfo.framebuffer = swapChainFramebuffers[imageIndex];
+    renderPassInfo.renderArea.offset = {0, 0};
+    renderPassInfo.renderArea.extent = surface.selectedExtent;
+    renderPassInfo.clearValueCount = 1;
+    renderPassInfo.pClearValues = &clearColor;
+
+    vkCmdBeginRenderPass(commandBuffers[currentFrame], &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
+
+    vkCmdBindPipeline(commandBuffers[currentFrame], VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);
+
+    VkBuffer vertexBuffers[] = {vertexBuffer};
+    VkDeviceSize offsets[] = {0};
+    vkCmdBindVertexBuffers(commandBuffers[currentFrame], 0, 1, vertexBuffers, offsets);
+
+    vkCmdBindIndexBuffer(commandBuffers[currentFrame], indexBuffer, 0, VK_INDEX_TYPE_UINT16);
+
+    vkCmdDrawIndexed(commandBuffers[currentFrame], 6, 1, 0, 0, 0);
+
+    vkCmdEndRenderPass(commandBuffers[currentFrame]);
+
+    if (vkEndCommandBuffer(commandBuffers[currentFrame]) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to record command buffer");
+    }
+
+    VkSemaphore waitSemaphores[] = {imageAvailableSemaphores[currentFrame]};
+    VkPipelineStageFlags waitStages[] = {VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
+    VkSemaphore signalSemaphores[] = {renderFinishedSemaphores[currentFrame]};
+    
+    VkSubmitInfo submitInfo{};
+    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    submitInfo.waitSemaphoreCount = 1;
+    submitInfo.pWaitSemaphores = waitSemaphores;
+    submitInfo.pWaitDstStageMask = waitStages;
+    submitInfo.commandBufferCount = 1;
+    submitInfo.pCommandBuffers = &commandBuffers[currentFrame];
+    submitInfo.signalSemaphoreCount = 1;
+    submitInfo.pSignalSemaphores = signalSemaphores;
+
+    if (vkQueueSubmit(queue.descriptor, 1, &submitInfo, inWorkFences[currentFrame]) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to submit draw command buffer");
+    }
+
+    currentFrame = (currentFrame + 1) % surface.imageCount;
+    
+    VkPresentInfoKHR presentInfo{};
+    presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
+    presentInfo.waitSemaphoreCount = 1;
+    presentInfo.pWaitSemaphores = signalSemaphores;
+    presentInfo.swapchainCount = 1;
+    presentInfo.pSwapchains = &swapChain;
+    presentInfo.pImageIndices = &imageIndex;
+
+    if (vkQueuePresentKHR(queue.descriptor, &presentInfo) != VK_SUCCESS) 
+    {
+        throw std::runtime_error("Unable to present swap chain image");
+    }
+}