Skip to content
The Chat Archive
gpt-4-0314· OpenAI WildChat-4.8M (AI2)

I’m building a video game engine using C++ as the coding language and Vulkan for…

  1. 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];
    
    // 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";
    
    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 = &currentCommandBuffer;
    
    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);
    
    std::cout << "Frame rendered: " << currentFrame << "\n";
    
    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.");
    }
    
    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;
    }
    

    }

    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 &currentCommandBuffer; }

    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; }

    I am running into some errors with the applications hanging at vkBeginCommandBuffer.I want to implement some Vulkan validation layers to better understand where things might be going wrong. How can I add these layers?

  2. Assistant

    To add Vulkan validation layers, you need to enable the VK_LAYER_KHRONOS_validation layer. You have already set up the validation layers vector in your code, but the initialization is inside an #ifdef block. Make sure you have defined NDEBUG when running in release mode and not defined it when running in debug mode.

    Here's a complete list of steps to enable the Vulkan Validation Layers in your code:

    1. Make sure you have the LunarG Vulkan SDK installed on your system. It provides the Validation Layers binaries. You can download it from LunarG's website.

    2. Make sure that the NDEBUG flag is not defined when you're building your application in Debug mode. This will enable the enableValidationLayers flag in your code.

    3. In the CreateInstance() function, before the vkCreateInstance call, add the following code to check for validation layer support:

    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.");
            }
        }
    }
    
    1. If the validation layers are supported, enable them during the instance creation by updating the createInfo object:
    if (enableValidationLayers) {
        createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
        createInfo.ppEnabledLayerNames = validationLayers.data();
    } else {
        createInfo.enabledLayerCount = 0;
    }
    
    1. Build and run your application in Debug mode. The Vulkan Validation Layers should now provide debugging information about your application during runtime. Make sure to check your console or debugger output for any error or warning messages.

    These changes are enough to enable validation layers. However, if you want to see more information during the debugging process, you can implement a custom Vulkan debug callback function to capture the validation layer messages. You can find more information on how to do this in the official Vulkan Tutorial.