Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· openaiHugging Face Suzhen/CodeChat

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 running into some errors in the Shutdown method of the Renderer class when I try to close the application. It seems to be running twice, which causes an error. Here is the code for the Main, Engine, Window and Renderer classes:

    Main.cpp:

    #include #define STB_IMAGE_IMPLEMENTATION #include "Engine.h"

    int main() { Engine engine = Engine::Instance();

    try {
        engine.Run();
    }
    catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
        return EXIT_FAILURE;
    }
    
    return EXIT_SUCCESS;
    

    }

    Engine.cpp:

    #include "Engine.h" #include

    Engine& Engine::Instance() { static Engine instance; // Singleton pattern return instance; }

    Engine::Engine() { Initialize(); }

    Engine::~Engine() { Shutdown(); }

    void Engine::Run() { MainLoop(); }

    void Engine::Initialize() { // Initialize window, renderer, and scene window.Initialize(); renderer.Initialize(window.GetWindow()); scene.Initialize(); }

    void Engine::MainLoop() { while (!window.ShouldClose()) { window.PollEvents();

    	float deltaTime = window.GetDeltaTime();
    	Update(deltaTime);
    	Render();
    }
    

    }

    void Engine::Update(float deltaTime) { scene.Update(deltaTime); }

    void Engine::Render() { renderer.BeginFrame(); scene.Render(renderer); renderer.EndFrame(); }

    void Engine::Shutdown() { // Clean up resources in reverse order

    }

    Window.cpp:

    #include "Window.h"

    Window::Window(int width, int height, const char* title) : width(width), height(height), title(title), lastFrameTime(0.0) { }

    Window::~Window() { Shutdown(); }

    void Window::Initialize() { // Initialize GLFW with Vulkan support glfwInit(); glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);

    // Create GLFW window
    window = glfwCreateWindow(width, height, title, nullptr, nullptr);
    
    // Set callback for framebuffer resizing
    glfwSetFramebufferSizeCallback(window, FramebufferResizeCallback);
    
    // Set the key callback function
    glfwSetKeyCallback(window, keyCallback);
    

    }

    void Window::PollEvents() { glfwPollEvents(); }

    void Window::Shutdown() { glfwDestroyWindow(window); glfwTerminate(); }

    bool Window::ShouldClose() const { return glfwWindowShouldClose(window); }

    GLFWwindow* Window::GetWindow() const { return window; }

    float Window::GetDeltaTime() { double currentFrameTime = glfwGetTime(); float deltaTime = static_cast(currentFrameTime - lastFrameTime); lastFrameTime = currentFrameTime; return deltaTime; }

    void Window::FramebufferResizeCallback(GLFWwindow* window, int width, int height) { // Inform the renderer that the framebuffer has been resized // (Not implemented here, must handle it in renderer/node update) }

    void Window::keyCallback(GLFWwindow* window, int key, int scancode, int action, int mods) { if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS) { // Close the window when the ESCAPE key is pressed glfwSetWindowShouldClose(window, GLFW_TRUE); } // other key events handling }

    Renderer.cpp:

    #include "Renderer.h"

    Renderer::Renderer() : currentFrame(0) { }

    Renderer::~Renderer() { Shutdown(); }

    void Renderer::Initialize(GLFWwindow* window) { this->window = window; CreateInstance(); CreateSurface(); ChoosePhysicalDevice(); CreateDevice(); CreateSwapchain(); CreateRenderPass(); CreateCommandPool(); CreateFramebuffers(); CreateSyncObjects(); }

    void Renderer::Shutdown() { if (device == VK_NULL_HANDLE) { // If the device is already VK_NULL_HANDLE, it means the cleanup has run before return; } std::cout << "Waiting for device idle…" << std::endl; vkDeviceWaitIdle(device); // Wait for rendering to complete std::cout << "Cleaning up framebuffers…" << std::endl; CleanupFramebuffers(); std::cout << "Cleaning up renderpass…" << std::endl; CleanupRenderPass(); std::cout << "Cleaning up syncobject…" << std::endl; CleanupSyncObjects(); std::cout << "Cleaning up commandbuffers…" << std::endl; CleanupCommandBuffers(); // Free command buffers before destroying the command pool CleanupCommandPool(); CleanupImageViews(); CleanupSwapchain(); CleanupDevice(); // Make sure that CleanupDevice is called before DestroySurface DestroySurface(); // Move this line after CleanupDevice CleanupInstance(); }

    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];
    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 = &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);
    
    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);

    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;
    

    }

    Do you know what might be causing the Renderer Shutdown to trigger twice and how to stop it from happening?

  2. Assistant

    It seems that your Renderer's Shutdown() function is triggered twice because the Engine's destructor calls Shutdown() and so does the program exit, causing the Renderer destructor to be called. You can add a flag to notify if the Shutdown() function has already been executed, which will prevent the issue from occurring.

    Modify the Rendererclass to add a bool shutdownInProgress member variable and initialize it to false in the constructor. Update the Shutdown() function as follows:

    Renderer.h:

    class Renderer
    {
        // ...
    private:
        bool shutdownInProgress;
        // ...
    };
    

    Renderer.cpp:

    Renderer::Renderer() : currentFrame(0), shutdownInProgress(false)
    {
    }
    
    Renderer::~Renderer()
    {
        Shutdown();
    }
    
    void Renderer::Shutdown()
    {
        if (device == VK_NULL_HANDLE || shutdownInProgress) {
            // If the device is already VK_NULL_HANDLE, or if Shutdown() is already in progress (already called once), then return and skip the cleanup
            return;
        }
        
        shutdownInProgress = true; // Indicate that the cleanup is in progress
    
        // ...
        // Keep the remaining cleanup code as is
        // ...
    }
    

    This will prevent the Renderer's Shutdown() function from running multiple times, preventing the error from occurring.

  3. User

    It seems this has not solved the issue. It still attempts to shutdown a second time and generates an Access Violation error.

  4. Assistant

    I apologize for the confusion. Here's an alternative approach.

    Update the main.cpp to dynamically allocate and deallocate the Engine instance as follows:

    main.cpp:

    #include <iostream>
    #define STB_IMAGE_IMPLEMENTATION
    #include "Engine.h"
    
    int main() {
        try {
            auto* engine = new Engine();
            engine->Run();
            delete engine;
        }
        catch (const std::exception& e) {
            std::cerr << e.what() << std::endl;
            return EXIT_FAILURE;
        }
    
        return EXIT_SUCCESS;
    }
    

    This change ensures that the Engine instance and its child objects (like Renderer) are properly destroyed in the correct order, preventing any double-destruction or access violation issues.

    Remember to remove the Singleton pattern from the Engine class if you don't need it anymore. As it is now, the dynamic allocation shouldn't cause any conflicts.

    Engine.h:

    // Remove Instance() function and the Singleton implementation.
    class Engine
    {
    public:
        Engine();
        ~Engine();
    
        void Run();
    
        // ...
    };
    

    If the access violation still persists, it may be caused by some other part of your code, and additional debugging would be required to pinpoint the issue. It might be helpful to use a debugger to trace the access violation error and check which part of the code is causing it.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.