I’m building a video game engine using C++ as the coding language and Vulkan for…
- User
I’m building a video game engine using C++ as the coding language and Vulkan for graphics. I am trying to set up a generic renderer using Vulkan that is flexible and will render objects based on a vector that is supplied to it. The renderer will also handle the creation of the window using GLFW and use GLM for all relevant math calls. I am using the ASSIMP library to load 3d models and animations.
Here is a portion of the code:
Renderer.h:
#pragma once
#include <vulkan/vulkan.h> #include "Window.h" #include #include #include #include #include #include "Pipeline.h" #include "Material.h" #include "Mesh.h"
struct QueueFamilyIndices { std::optional<uint32_t> graphicsFamily; std::optional<uint32_t> presentFamily;
bool IsComplete() { return graphicsFamily.has_value() && presentFamily.has_value(); }};
struct SwapChainSupportDetails { VkSurfaceCapabilitiesKHR capabilities; std::vector formats; std::vector presentModes; };
class Renderer { public: Renderer(); ~Renderer();
void Initialize(GLFWwindow* window); void Shutdown(); void BeginFrame(); void EndFrame(); VkDescriptorSetLayout CreateDescriptorSetLayout(); VkDescriptorPool CreateDescriptorPool(uint32_t maxSets); VkDevice* GetDevice(); VkPhysicalDevice* GetPhysicalDevice(); VkCommandPool* GetCommandPool(); VkQueue* GetGraphicsQueue(); VkCommandBuffer* GetCurrentCommandBuffer(); std::shared_ptr<Pipeline> GetPipeline(); void CreateGraphicsPipeline(Mesh* mesh, Material* material);private: bool shutdownInProgress; uint32_t currentCmdBufferIndex = 0;
std::vector<VkImage> swapChainImages; std::vector<VkImageView> swapChainImageViews; VkExtent2D swapChainExtent; VkRenderPass renderPass; uint32_t imageIndex; std::shared_ptr<Pipeline> pipeline; VkFormat swapChainImageFormat; std::vector<VkCommandBuffer> commandBuffers; void CreateImageViews(); void CleanupImageViews(); void CreateRenderPass(); void CleanupRenderPass(); void CreateSurface(); void DestroySurface(); void CreateInstance(); void CleanupInstance(); void ChoosePhysicalDevice(); void CreateDevice(); void CleanupDevice(); void CreateSwapchain(); void CleanupSwapchain(); void CreateCommandPool(); void CleanupCommandPool(); void CreateFramebuffers(); void CleanupFramebuffers(); void CreateCommandBuffers(); void CleanupCommandBuffers(); GLFWwindow* window; VkInstance instance = VK_NULL_HANDLE; VkPhysicalDevice physicalDevice = VK_NULL_HANDLE; VkDevice device = VK_NULL_HANDLE; VkSurfaceKHR surface; VkSwapchainKHR swapchain; VkCommandPool commandPool; VkCommandBuffer currentCommandBuffer; std::vector<VkFramebuffer> framebuffers; // Additional Vulkan objects needed for rendering… const uint32_t kMaxFramesInFlight = 2; std::vector<VkSemaphore> imageAvailableSemaphores; std::vector<VkSemaphore> renderFinishedSemaphores; std::vector<VkFence> inFlightFences; size_t currentFrame; VkQueue graphicsQueue; VkQueue presentQueue; void CreateSyncObjects(); void CleanupSyncObjects(); SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface); VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats); VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes); VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window); std::vector<const char*> deviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME }; std::vector<const char*> CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice); QueueFamilyIndices GetQueueFamilyIndices(VkPhysicalDevice physicalDevice);};
Renderer.cpp:
#include "Renderer.h"
Renderer::Renderer() : currentFrame(0), shutdownInProgress(false) { }
Renderer::~Renderer() { Shutdown(); }
void Renderer::Initialize(GLFWwindow* window) { this->window = window; CreateInstance(); CreateSurface(); ChoosePhysicalDevice(); CreateDevice(); CreateSwapchain(); CreateRenderPass(); CreateCommandPool(); CreateFramebuffers(); CreateSyncObjects(); }
void Renderer::Shutdown() { if (shutdownInProgress) { return; }
shutdownInProgress = true; if (device != VK_NULL_HANDLE) { vkDeviceWaitIdle(device); } CleanupFramebuffers(); CleanupRenderPass(); CleanupSyncObjects(); CleanupCommandBuffers(); CleanupCommandPool(); CleanupImageViews(); CleanupSwapchain(); if (device != VK_NULL_HANDLE) { CleanupDevice(); } DestroySurface(); CleanupInstance(); shutdownInProgress = false;}
void Renderer::BeginFrame() { // Wait for any previous work on this swapchain image to complete vkWaitForFences(device, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX); vkResetFences(device, 1, &inFlightFences[currentFrame]);
// Acquire an image from the swapchain, then begin recording commands for the current frame. VkResult acquireResult = vkAcquireNextImageKHR(device, swapchain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex); if (acquireResult != VK_SUCCESS && acquireResult != VK_SUBOPTIMAL_KHR) { throw std::runtime_error("Failed to acquire next swapchain image."); } VkCommandBufferBeginInfo beginInfo{}; beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; //currentCommandBuffer = commandBuffers[currentFrame]; currentCmdBufferIndex = (currentCmdBufferIndex + 1) % 2; currentCommandBuffer = commandBuffers[currentFrame * 2 + currentCmdBufferIndex]; vkBeginCommandBuffer(currentCommandBuffer, &beginInfo); VkRenderPassBeginInfo renderPassInfo{}; renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; renderPassInfo.renderPass = renderPass; renderPassInfo.framebuffer = framebuffers[imageIndex]; renderPassInfo.renderArea.offset = { 0, 0 }; renderPassInfo.renderArea.extent = swapChainExtent; // Set the clear color to black VkClearValue clearColor = { 0.0f, 0.0f, 0.0f, 1.0f }; renderPassInfo.clearValueCount = 1; renderPassInfo.pClearValues = &clearColor; vkCmdBeginRenderPass(currentCommandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);}
void Renderer::EndFrame() { vkCmdEndRenderPass(currentCommandBuffer);
VkSubmitInfo submitInfo{}; submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT }; submitInfo.waitSemaphoreCount = 1; submitInfo.pWaitSemaphores = &imageAvailableSemaphores[currentFrame]; submitInfo.pWaitDstStageMask = waitStages; submitInfo.commandBufferCount = 1; submitInfo.pCommandBuffers = ¤tCommandBuffer; submitInfo.signalSemaphoreCount = 1; submitInfo.pSignalSemaphores = &renderFinishedSemaphores[currentFrame]; vkEndCommandBuffer(currentCommandBuffer); vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]); VkPresentInfoKHR presentInfo{}; presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; presentInfo.waitSemaphoreCount = 1; presentInfo.pWaitSemaphores = &renderFinishedSemaphores[currentFrame]; VkSwapchainKHR swapChains[] = { swapchain }; presentInfo.swapchainCount = 1; presentInfo.pSwapchains = swapChains; presentInfo.pImageIndices = &imageIndex; VkResult queuePresentResult = vkQueuePresentKHR(presentQueue, &presentInfo); if (queuePresentResult == VK_ERROR_OUT_OF_DATE_KHR || queuePresentResult == VK_SUBOPTIMAL_KHR) { // Handle swapchain recreation if needed, e.g., due to resizing the window or other swapchain properties changes } else if (queuePresentResult != VK_SUCCESS) { throw std::runtime_error("Failed to present the swapchain image."); } currentFrame = (currentFrame + 1) % kMaxFramesInFlight;}
void Renderer::CreateSurface() { if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) { throw std::runtime_error("Failed to create a window surface."); } }
void Renderer::DestroySurface() { vkDestroySurfaceKHR(instance, surface, nullptr); }
void Renderer::CreateInstance() { // Set up the application info VkApplicationInfo appInfo{}; appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; appInfo.pApplicationName = "Game Engine"; appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0); appInfo.pEngineName = "Game Engine"; appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0); appInfo.apiVersion = VK_API_VERSION_1_2;
// Set up the instance create info VkInstanceCreateInfo createInfo{}; createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; createInfo.pApplicationInfo = &appInfo; // Set up the required extensions uint32_t glfwExtensionCount = 0; const char** glfwExtensions; glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount); createInfo.enabledExtensionCount = glfwExtensionCount; createInfo.ppEnabledExtensionNames = glfwExtensions; createInfo.enabledLayerCount = 0; // Create the Vulkan instance if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) { throw std::runtime_error("Failed to create the Vulkan instance."); }}
void Renderer::CleanupInstance() { // Destroy the Vulkan instance vkDestroyInstance(instance, nullptr); }
void Renderer::ChoosePhysicalDevice() { // Enumerate the available physical devices and choose one that supports required features uint32_t deviceCount = 0; vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
if (deviceCount == 0) { throw std::runtime_error("Failed to find a GPU with Vulkan support."); } std::vector<VkPhysicalDevice> allDevices(deviceCount); vkEnumeratePhysicalDevices(instance, &deviceCount, allDevices.data()); for (const auto& testDevice : allDevices) { if (glfwGetPhysicalDevicePresentationSupport(instance, testDevice, 0) && CheckPhysicalDeviceExtensionSupport(testDevice).empty() && GetQueueFamilyIndices(testDevice).IsComplete()) { physicalDevice = testDevice; break; } } if (physicalDevice == VK_NULL_HANDLE) { throw std::runtime_error("Failed to find a suitable GPU."); }}
void Renderer::CreateDevice() { // Get the GPU’s queue family indices const QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice);
// Set up the device queue create info std::vector<VkDeviceQueueCreateInfo> queueCreateInfos; std::set<uint32_t> uniqueQueueFamilyIndices = { indices.graphicsFamily.value(),indices.presentFamily.value() }; float queuePriority = 1.0f; for (uint32_t queueFamilyIndex : uniqueQueueFamilyIndices) { VkDeviceQueueCreateInfo queueCreateInfo{}; queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; queueCreateInfo.queueFamilyIndex = queueFamilyIndex; queueCreateInfo.queueCount = 1; queueCreateInfo.pQueuePriorities = &queuePriority; queueCreateInfos.push_back(queueCreateInfo); } // Set up the physical device features VkPhysicalDeviceFeatures deviceFeatures{}; // Set up the device create info VkDeviceCreateInfo createInfo{}; createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size()); createInfo.pQueueCreateInfos = queueCreateInfos.data(); createInfo.pEnabledFeatures = &deviceFeatures; createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size()); createInfo.ppEnabledExtensionNames = deviceExtensions.data(); // Create the logical device if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS) { throw std::runtime_error("Failed to create a logical device."); } // Retrieve the graphics queue and the present queue vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue); vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);}
void Renderer::CleanupDevice() { // Destroy the logical device vkDestroyDevice(device, nullptr); }
void Renderer::CreateSwapchain() { // Get swapchain support details SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice,surface);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats); swapChainImageFormat = surfaceFormat.format; // Initialize the swapChainImageFormat VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes); VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities,window); uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1; if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount) { imageCount = swapChainSupport.capabilities.maxImageCount; } // Create the swapchain // … VkSwapchainCreateInfoKHR createInfo{}; createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; createInfo.surface = surface; createInfo.minImageCount = imageCount; createInfo.imageFormat = surfaceFormat.format; createInfo.imageColorSpace = surfaceFormat.colorSpace; createInfo.imageExtent = extent; createInfo.imageArrayLayers = 1; createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; QueueFamilyIndices indices = GetQueueFamilyIndices(physicalDevice); uint32_t queueFamilyIndices[] = { indices.graphicsFamily.value(), indices.presentFamily.value() }; if (indices.graphicsFamily != indices.presentFamily) { createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT; createInfo.queueFamilyIndexCount = 2; createInfo.pQueueFamilyIndices = queueFamilyIndices; } else { createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; } createInfo.preTransform = swapChainSupport.capabilities.currentTransform; createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; createInfo.presentMode = presentMode; createInfo.clipped = VK_TRUE; if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapchain) != VK_SUCCESS) { throw std::runtime_error("failed to create swap chain!"); } // Retrieve swapchain images (color buffers) // … // Retrieve swapchain images vkGetSwapchainImagesKHR(device, swapchain, &imageCount, nullptr); swapChainImages.resize(imageCount); vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapChainImages.data()); // Create image views for swapchain images CreateImageViews();}
void Renderer::CleanupSwapchain() { // Clean up Vulkan swapchain if (swapchain != VK_NULL_HANDLE) { vkDestroySwapchainKHR(device, swapchain, nullptr); swapchain = VK_NULL_HANDLE; } }
void Renderer::CreateImageViews() { swapChainImageViews.resize(swapChainImages.size());
for (size_t i = 0; i < swapChainImages.size(); ++i) { VkImageViewCreateInfo createInfo{}; createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; createInfo.image = swapChainImages[i]; createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; createInfo.format = swapChainImageFormat; createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY; createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY; createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY; createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY; createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; createInfo.subresourceRange.baseMipLevel = 0; createInfo.subresourceRange.levelCount = 1; createInfo.subresourceRange.baseArrayLayer = 0; createInfo.subresourceRange.layerCount = 1; createInfo.flags = 0; if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS) { throw std::runtime_error("Failed to create an image view."); } }}
void Renderer::CleanupImageViews() { for (auto imageView : swapChainImageViews) { vkDestroyImageView(device, imageView, nullptr); } swapChainImageViews.clear(); }
void Renderer::CreateRenderPass() { VkAttachmentDescription colorAttachment{}; colorAttachment.format = swapChainImageFormat; colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT; colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
VkAttachmentReference colorAttachmentRef{}; colorAttachmentRef.attachment = 0; colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; VkSubpassDescription subpass{}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &colorAttachmentRef; VkRenderPassCreateInfo renderPassInfo{}; renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; renderPassInfo.attachmentCount = 1; renderPassInfo.pAttachments = &colorAttachment; renderPassInfo.subpassCount = 1; renderPassInfo.pSubpasses = &subpass; VkSubpassDependency dependency{}; dependency.srcSubpass = VK_SUBPASS_EXTERNAL; dependency.dstSubpass = 0; dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; dependency.srcAccessMask = 0; dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; renderPassInfo.dependencyCount = 1; renderPassInfo.pDependencies = &dependency; if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) { throw std::runtime_error("Failed to create render pass."); }}
void Renderer::CleanupRenderPass() { vkDestroyRenderPass(device, renderPass, nullptr); }
void Renderer::CreateCommandPool() { // Find a queue family index that supports graphics operations QueueFamilyIndices queueFamilyIndices = GetQueueFamilyIndices(physicalDevice);
// Create a command pool for the queue family VkCommandPoolCreateInfo poolInfo{}; poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value(); poolInfo.flags = 0; if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS) { throw std::runtime_error("Failed to create command pool."); } CreateCommandBuffers(); // Create command buffers after creating the command pool}
void Renderer::CleanupCommandPool() { // Clean up Vulkan command pool CleanupCommandBuffers(); // Add this line to clean up command buffers before destroying the command pool vkDestroyCommandPool(device, commandPool, nullptr); }
void Renderer::CreateCommandBuffers() { //commandBuffers.resize(kMaxFramesInFlight); commandBuffers.resize(kMaxFramesInFlight * 2);
VkCommandBufferAllocateInfo allocInfo{}; allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; allocInfo.commandPool = commandPool; allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; allocInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size()); if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS) { throw std::runtime_error("Failed to allocate command buffers."); } // Set the initial value of the currentCommandBuffer currentCommandBuffer = commandBuffers[currentFrame];}
void Renderer::CleanupCommandBuffers() { vkFreeCommandBuffers(device, commandPool, static_cast<uint32_t>(commandBuffers.size()), commandBuffers.data()); }
void Renderer::CreateFramebuffers() { // Check if the framebuffers vector is not empty, and call CleanupFramebuffers() if (!framebuffers.empty()) { CleanupFramebuffers(); }
// Create Vulkan framebuffers for swapchain images framebuffers.resize(swapChainImageViews.size()); for (size_t 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 = swapChainExtent.width; framebufferInfo.height = swapChainExtent.height; framebufferInfo.layers = 1; if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &framebuffers[i]) != VK_SUCCESS) { throw std::runtime_error("Failed to create framebuffer."); } }}
void Renderer::CleanupFramebuffers() { for (auto framebuffer : framebuffers) { if (framebuffer != VK_NULL_HANDLE) { vkDestroyFramebuffer(device, framebuffer, nullptr); framebuffer = VK_NULL_HANDLE; } } framebuffers.clear(); // Make sure to clear the framebuffers vector after destroying each framebuffer }
void Renderer::CreateSyncObjects() { imageAvailableSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE); renderFinishedSemaphores.resize(kMaxFramesInFlight, VK_NULL_HANDLE); inFlightFences.resize(kMaxFramesInFlight, VK_NULL_HANDLE);
VkSemaphoreCreateInfo semaphoreInfo{}; semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; VkFenceCreateInfo fenceInfo{}; fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT; for (size_t i = 0; i < kMaxFramesInFlight; ++i) { if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS || vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS || vkCreateFence(device, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS) { throw std::runtime_error("Failed to create synchronization objects for a frame."); } }}
void Renderer::CleanupSyncObjects() { for (size_t i = 0; i < kMaxFramesInFlight; ++i) { if (renderFinishedSemaphores[i] != VK_NULL_HANDLE) vkDestroySemaphore(device, renderFinishedSemaphores[i], nullptr); if (imageAvailableSemaphores[i] != VK_NULL_HANDLE) vkDestroySemaphore(device, imageAvailableSemaphores[i], nullptr); if (inFlightFences[i] != VK_NULL_HANDLE) vkDestroyFence(device, inFlightFences[i], nullptr); } }
SwapChainSupportDetails Renderer::querySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface) { SwapChainSupportDetails details;
// Query the capabilities vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities); // Query the supported formats uint32_t formatCount; vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr); if (formatCount != 0) { details.formats.resize(formatCount); vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data()); } // Query the supported present modes uint32_t presentModeCount; vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr); if (presentModeCount != 0) { details.presentModes.resize(presentModeCount); vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data()); } return details;}
VkSurfaceFormatKHR Renderer::chooseSwapSurfaceFormat(const std::vector& availableFormats) { for (const auto& availableFormat : availableFormats) { if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) { return availableFormat; } } return availableFormats[0]; }
VkPresentModeKHR Renderer::chooseSwapPresentMode(const std::vector& availablePresentModes) { for (const auto& availablePresentMode : availablePresentModes) { if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR) { return availablePresentMode; } } return VK_PRESENT_MODE_FIFO_KHR; }
VkExtent2D Renderer::chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities, GLFWwindow* window) { if (capabilities.currentExtent.width != UINT32_MAX) { return capabilities.currentExtent; } else { int width, height; glfwGetFramebufferSize(window, &width, &height);
VkExtent2D actualExtent = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) }; actualExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, actualExtent.width)); actualExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, actualExtent.height)); return actualExtent; }}
std::vector<const char*> Renderer::CheckPhysicalDeviceExtensionSupport(VkPhysicalDevice physicalDevice) { uint32_t extensionCount; vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, nullptr);
std::vector<VkExtensionProperties> availableExtensions(extensionCount); vkEnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extensionCount, availableExtensions.data()); std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end()); for (const auto& extension : availableExtensions) { requiredExtensions.erase(extension.extensionName); } std::vector<const char*> remainingExtensions; for (const auto& extension : requiredExtensions) { remainingExtensions.push_back(extension.c_str()); } return remainingExtensions;}
QueueFamilyIndices Renderer::GetQueueFamilyIndices(VkPhysicalDevice physicalDevice) { QueueFamilyIndices indices;
uint32_t queueFamilyCount = 0; vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, nullptr); std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount); vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamilyCount, queueFamilies.data()); int i = 0; for (const auto& queueFamily : queueFamilies) { if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) { indices.graphicsFamily = i; } VkBool32 presentSupport = false; vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, i, surface, &presentSupport); if (presentSupport) { indices.presentFamily = i; } if (indices.IsComplete()) { break; } i++; } return indices;}
VkDevice* Renderer::GetDevice() { return &device; }; VkPhysicalDevice* Renderer::GetPhysicalDevice() { return &physicalDevice; }; VkCommandPool* Renderer::GetCommandPool() { return &commandPool; }; VkQueue* Renderer::GetGraphicsQueue() { return &graphicsQueue; };
VkCommandBuffer* Renderer::GetCurrentCommandBuffer() { return ¤tCommandBuffer; }
VkDescriptorSetLayout Renderer::CreateDescriptorSetLayout() { VkDescriptorSetLayoutBinding uboLayoutBinding{}; uboLayoutBinding.binding = 0; uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; uboLayoutBinding.descriptorCount = 1; uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT; uboLayoutBinding.pImmutableSamplers = nullptr;
VkDescriptorSetLayoutCreateInfo layoutInfo{}; layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; layoutInfo.bindingCount = 1; layoutInfo.pBindings = &uboLayoutBinding; VkDescriptorSetLayout descriptorSetLayout; if (vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout) != VK_SUCCESS) { throw std::runtime_error("Failed to create descriptor set layout!"); } return descriptorSetLayout;}
VkDescriptorPool Renderer::CreateDescriptorPool(uint32_t maxSets) { VkDescriptorPoolSize poolSize{}; poolSize.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; poolSize.descriptorCount = maxSets;
VkDescriptorPoolCreateInfo poolInfo{}; poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; poolInfo.poolSizeCount = 1; poolInfo.pPoolSizes = &poolSize; poolInfo.maxSets = maxSets; VkDescriptorPool descriptorPool; if (vkCreateDescriptorPool(device, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) { throw std::runtime_error("Failed to create descriptor pool!"); } return descriptorPool;}
void Renderer::CreateGraphicsPipeline(Mesh* mesh, Material* material) {
if (pipeline) { pipeline->Cleanup(); } // Create pipeline object and configure its properties pipeline = std::make_shared<Pipeline>(); pipeline->CreateGraphicsPipeline(mesh->GetVertexInputBindingDescriptions(), mesh->GetVertexInputAttributeDescriptions(), swapChainExtent, {material->GetvertexShader().get(), material->GetfragmentShader().get()}, renderPass, material->GetPipelineLayout(), device);}
std::shared_ptr Renderer::GetPipeline() { return pipeline; }
The code seems to hang at this line of code in the Renderer::BeginFrame method:
vkBeginCommandBuffer(currentCommandBuffer, &beginInfo);
It does this after renderering several frames, but then just stops progressing past this line. The application completely stops at this point. Any ideas of what the issue could be?
- Assistant
It seems that the issue might be related to the synchronization of your command buffers. The code hangs at
vkBeginCommandBuffer()because the command buffer is still in use, and you need to properly wait for the command buffer to be available before trying to re-record it.One way to fix this is by using a fence for each command buffer and waiting for the fence to signal before re-recording the command buffer. Here's how you can modify your code to achieve that:
- Modify the
Renderer.hfile by adding a vector for fences associated with each command buffer.
std::vector<VkFence> cmdBufferFences;- Add a method to create and cleanup command buffer fences in the
Renderer.hfile.
void CreateCommandBufferFences(); void CleanupCommandBufferFences();- Modify the
Renderer.cppfile to create and cleanup the fences in theInitializeandShutdownmethods, respectively.
void Renderer::Initialize(GLFWwindow* window) { ... CreateCommandPool(); CreateCommandBufferFences(); // Add this line after creating the command pool // ... }void Renderer::Shutdown() { ... CleanupCommandBufferFences(); // Add this line before cleaning up the command pool CleanupCommandPool(); ... }- Implement the
CreateCommandBufferFencesandCleanupCommandBufferFencesmethods in theRenderer.cppfile.
void Renderer::CreateCommandBufferFences() { cmdBufferFences.resize(commandBuffers.size()); VkFenceCreateInfo fenceInfo{}; fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT; for (size_t i = 0; i < cmdBufferFences.size(); ++i) { if (vkCreateFence(device, &fenceInfo, nullptr, &cmdBufferFences[i]) != VK_SUCCESS) { throw std::runtime_error("Failed to create command buffer fence."); } } } void Renderer::CleanupCommandBufferFences() { for (auto fence : cmdBufferFences) { if (fence != VK_NULL_HANDLE) { vkDestroyFence(device, fence, nullptr); fence = VK_NULL_HANDLE; } } }- In the
Renderer::BeginFrame()method, wait for the related fence to signal before callingvkBeginCommandBuffer.
void Renderer::BeginFrame() { // Add this line to wait for the currentCmdBufferIndex fence vkWaitForFences(device, 1, &cmdBufferFences[currentCmdBufferIndex], VK_TRUE, UINT64_MAX); vkResetFences(device, 1, &cmdBufferFences[currentCmdBufferIndex]); ... }With these changes, your code should not hang at the
vkBeginCommandBuffer()line, and it will properly wait for the command buffer to be available before re-recording it. - Modify the
- User
Fence related methods are already implemented in the code along with vkWaitForFences and vkResetFences in the BeginFrame method. I don't think that's the issue.
- Assistant
You are correct, the fence related methods are already implemented in your code. I apologize for overlooking that. In that case, we can try another approach to debug the problem:
- First, make sure you have enabled the Vulkan Validation Layers. This can help catch any issues or errors during the runtime. To enable the validation layers, add the following code in the
CreateInstance()method in theRenderer.cppfile:
std::vector<const char*> validationLayers; #ifdef NDEBUG const bool enableValidationLayers = false; #else const bool enableValidationLayers = true; validationLayers.push_back("VK_LAYER_KHRONOS_validation"); #endif if (enableValidationLayers) { // Check if validation layers are supported uint32_t layerCount; vkEnumerateInstanceLayerProperties(&layerCount, nullptr); std::vector<VkLayerProperties> availableLayers(layerCount); vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data()); for (const char* layerName : validationLayers) { bool layerFound = false; for (const auto& layerProperties : availableLayers) { if (strcmp(layerName, layerProperties.layerName) == 0) { layerFound = true; break; } } if (!layerFound) { throw std::runtime_error("Validation layer requested, but it's not available."); } } // Enable the validation layers createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size()); createInfo.ppEnabledLayerNames = validationLayers.data(); } else { createInfo.enabledLayerCount = 0; }Also, add the following code at the beginning of the
Renderer.cppfile:#include <cstring>- Add some debug messages to your
BeginFrame()andEndFrame()methods to track the current frame, command buffer index, and image index in the console:
void Renderer::BeginFrame() { ... // Add debug message before vkBeginCommandBuffer std::cout << "Current Frame: " << currentFrame << " | Cmd Buffer Index: " << currentCmdBufferIndex << " | Image Index: " << imageIndex << "\n"; std::cout << "Calling vkBeginCommandBuffer...\n"; vkBeginCommandBuffer(currentCommandBuffer, &beginInfo); std::cout << "vkBeginCommandBuffer called...\n"; ... } void Renderer::EndFrame() { ... // Add debug message after vkQueuePresentKHR std::cout << "Frame rendered: " << currentFrame << "\n"; ... }Run the application after these modifications and observe the console output. It might help you identify the source of the problem or show if there's an issue or error reported by the Vulkan validation layers.
- First, make sure you have enabled the Vulkan Validation Layers. This can help catch any issues or errors during the runtime. To enable the validation layers, add the following code in the