project-aster/samples/04_scenes/main.cpp

// =============================================
//  Aster: main.cpp
//  Copyright (c) 2020-2024 Anish Bhobe
// =============================================

#include "context.h"
#include "device.h"
#include "helpers.h"
#include "physical_device.h"
#include "render_resource_manager.h"
#include "swapchain.h"
#include "window.h"

#include "asset_loader.h"
#include "camera.h"
#include "core_components.h"
#include "light_manager.h"

#include "ecs_adapter.h"
#include "frame.h"
#include "ibl_helpers.h"
#include "image.h"
#include "pipeline.h"

#include "pipeline_utils.h"

constexpr u32 MAX_FRAMES_IN_FLIGHT = 3;
constexpr auto PIPELINE_CACHE_FILE = "PipelineCacheData.bin";
constexpr auto MODEL_FILE = "model/DamagedHelmet.glb";
constexpr auto MODEL_FILE2 = "model/Box.glb";
constexpr auto BACKDROP_FILE = "image/photo_studio_loft_hall_4k.hdr";
constexpr u32 INIT_WIDTH = 640;
constexpr u32 INIT_HEIGHT = 480;

int
main(int, char *[])
{
    MIN_LOG_LEVEL(Logger::LogType::eInfo);

    Context context = {"Scene Render [WIP]", VERSION};
    Window window = {"Scene Render [WIP] (Aster)", &context, {INIT_WIDTH, INIT_HEIGHT}};

    PhysicalDevices physicalDevices = {&window, &context};
    PhysicalDevice deviceToUse = FindSuitableDevice(physicalDevices);

    vk::Extent2D internalResolution = {1920, 1080};
    internalResolution.width = (internalResolution.height * INIT_WIDTH) / INIT_HEIGHT;

    CameraController cameraController = {vec3{0.0f, 2.0f, 4.0f}, vec3{0.0f, 0.0f, 0.0f}, 70_deg,
                                         Cast<f32>(internalResolution.width) / Cast<f32>(internalResolution.height)};

    INFO("Using {} as the primary device.", deviceToUse.m_DeviceProperties.deviceName.data());

    Features enabledDeviceFeatures = {
        .m_Vulkan10Features =
            {
                .multiDrawIndirect = true,
                .samplerAnisotropy = true,
                .shaderInt64 = true,
            },
        .m_Vulkan11Features =
            {
                .shaderDrawParameters = true,
            },
        .m_Vulkan12Features =
            {
                .descriptorIndexing = true,
                .shaderSampledImageArrayNonUniformIndexing = true,
                .shaderStorageBufferArrayNonUniformIndexing = true,
                .shaderStorageImageArrayNonUniformIndexing = true,
                .descriptorBindingUniformBufferUpdateAfterBind = true, // Not related to Bindless
                .descriptorBindingSampledImageUpdateAfterBind = true,
                .descriptorBindingStorageImageUpdateAfterBind = true,
                .descriptorBindingStorageBufferUpdateAfterBind = true,
                .descriptorBindingPartiallyBound = true,
                .runtimeDescriptorArray = true,
                .bufferDeviceAddress = true,
                .bufferDeviceAddressCaptureReplay = true,
            },
        .m_Vulkan13Features =
            {
                .synchronization2 = true,
                .dynamicRendering = true,
            },
    };

    auto attachmentFormat = vk::Format::eR8G8B8A8Srgb;
    auto pipelineCacheData = ReadFileBytes(PIPELINE_CACHE_FILE, false);

    QueueAllocation queueAllocation = FindAppropriateQueueAllocation(&deviceToUse);
    Device device = {&context,          &deviceToUse,      &enabledDeviceFeatures,
                     {queueAllocation}, pipelineCacheData, "Primary Device"};
    vk::Queue graphicsQueue = device.GetQueue(queueAllocation.m_Family, 0);
    Swapchain swapchain = {&window, &device, "Primary Chain"};

    RenderResourceManager resourceManager = {&device, 1024};
    EcsRegistry registry;

    AssetLoader assetLoader = {&resourceManager, &registry, graphicsQueue, queueAllocation.m_Family,
                               queueAllocation.m_Family};
    LightManager lightManager = LightManager{&resourceManager};

    Texture environmentHdri;
    assetLoader.LoadHdrImage(&environmentHdri, BACKDROP_FILE);
    auto envHdriHandle = resourceManager.CommitTexture(&environmentHdri);

    auto environment = CreateEnvironment(&assetLoader, graphicsQueue, 512, envHdriHandle, "Cube Env");

    resourceManager.Release(envHdriHandle);

    lightManager.SetEnvironment(&environment);

    eastl::vector<Model> models;
    for (int i = -1; i <= 1; ++i)
    {
        for (int j = -1; j <= 1; ++j)
        {
            INFO("{}, {}", i, j);
            auto &model = models.emplace_back(std::move(assetLoader.LoadModelToGpu(MODEL_FILE, "Main Model")));
            registry.get<CDynamicTransform>(model.m_RootEntity).m_Position = vec3(2 * i, 0, 2 * j);
        }
    }

    UniformBuffer ubo;
    constexpr usize uboLightManagerOffset = sizeof cameraController.m_Camera;
    constexpr usize uboTotalSize = uboLightManagerOffset + sizeof lightManager.m_MetaInfo;
    ubo.Init(&device, uboTotalSize, "Desc1 UBO");
    ubo.Write(&device, 0, sizeof cameraController.m_Camera, &cameraController.m_Camera);
    ubo.Write(&device, uboLightManagerOffset, sizeof lightManager.m_MetaInfo, &lightManager.m_MetaInfo);

    Pipeline pipeline = CreatePipeline(&device, attachmentFormat, &resourceManager);
    Pipeline backgroundPipeline = CreateBackgroundPipeline(&device, attachmentFormat, &resourceManager);

    vk::DescriptorPool descriptorPool;
    vk::DescriptorSet perFrameDescriptor;

    {
        vk::DescriptorSetLayout descriptorSetLayout = pipeline.m_SetLayouts[1];
        eastl::array poolSizes = {
            vk::DescriptorPoolSize{
                .type = vk::DescriptorType::eUniformBuffer,
                .descriptorCount = 3,
            },
        };
        vk::DescriptorPoolCreateInfo descriptorPoolCreateInfo = {
            .maxSets = 1, .poolSizeCount = Cast<u32>(poolSizes.size()), .pPoolSizes = poolSizes.data()};
        AbortIfFailed(device.m_Device.createDescriptorPool(&descriptorPoolCreateInfo, nullptr, &descriptorPool));

        vk::DescriptorSetAllocateInfo descriptorSetAllocateInfo = {
            .descriptorPool = descriptorPool,
            .descriptorSetCount = 1,
            .pSetLayouts = &descriptorSetLayout,
        };
        AbortIfFailed(device.m_Device.allocateDescriptorSets(&descriptorSetAllocateInfo, &perFrameDescriptor));
    }

    vk::DescriptorBufferInfo camLightBufferInfo = {
        .buffer = ubo.m_Buffer,
        .offset = 0,
        .range = uboTotalSize,
    };
    eastl::array writeDescriptors = {
        vk::WriteDescriptorSet{
            .dstSet = perFrameDescriptor,
            .dstBinding = 0,
            .dstArrayElement = 0,
            .descriptorCount = 1,
            .descriptorType = vk::DescriptorType::eUniformBuffer,
            .pBufferInfo = &camLightBufferInfo,
        },
    };
    device.m_Device.updateDescriptorSets(Cast<u32>(writeDescriptors.size()), writeDescriptors.data(), 0, nullptr);

    // Persistent variables
    vk::Viewport viewport = {
        .x = 0,
        .y = Cast<f32>(internalResolution.height),
        .width = Cast<f32>(internalResolution.width),
        .height = -Cast<f32>(internalResolution.height),
        .minDepth = 0.0,
        .maxDepth = 1.0,
    };

    vk::Rect2D scissor = {
        .offset = {0, 0},
        .extent = internalResolution,
    };

    vk::ImageSubresourceRange subresourceRange = {
        .aspectMask = vk::ImageAspectFlagBits::eColor,
        .baseMipLevel = 0,
        .levelCount = 1,
        .baseArrayLayer = 0,
        .layerCount = 1,
    };

    vk::ImageMemoryBarrier2 preRenderBarrier = {
        .srcStageMask = vk::PipelineStageFlagBits2::eTopOfPipe,
        .srcAccessMask = vk::AccessFlagBits2::eNone,
        .dstStageMask = vk::PipelineStageFlagBits2::eColorAttachmentOutput,
        .dstAccessMask = vk::AccessFlagBits2::eColorAttachmentWrite,
        .oldLayout = vk::ImageLayout::eUndefined,
        .newLayout = vk::ImageLayout::eColorAttachmentOptimal,
        .srcQueueFamilyIndex = queueAllocation.m_Family,
        .dstQueueFamilyIndex = queueAllocation.m_Family,
        .subresourceRange = subresourceRange,
    };
    vk::DependencyInfo preRenderDependencies = {
        .imageMemoryBarrierCount = 1,
        .pImageMemoryBarriers = &preRenderBarrier,
    };

    vk::ImageMemoryBarrier2 renderToBlitBarrier = {
        .srcStageMask = vk::PipelineStageFlagBits2::eColorAttachmentOutput,
        .srcAccessMask = vk::AccessFlagBits2::eColorAttachmentWrite,
        .dstStageMask = vk::PipelineStageFlagBits2::eAllTransfer,
        .dstAccessMask = vk::AccessFlagBits2::eTransferRead,
        .oldLayout = vk::ImageLayout::eColorAttachmentOptimal,
        .newLayout = vk::ImageLayout::eTransferSrcOptimal,
        .srcQueueFamilyIndex = queueAllocation.m_Family,
        .dstQueueFamilyIndex = queueAllocation.m_Family,
        .subresourceRange = subresourceRange,
    };
    vk::ImageMemoryBarrier2 acquireToTransferDstBarrier = {
        .srcStageMask = vk::PipelineStageFlagBits2::eTopOfPipe,
        .srcAccessMask = vk::AccessFlagBits2::eNone,
        .dstStageMask = vk::PipelineStageFlagBits2::eAllTransfer,
        .dstAccessMask = vk::AccessFlagBits2::eTransferWrite,
        .oldLayout = vk::ImageLayout::eUndefined,
        .newLayout = vk::ImageLayout::eTransferDstOptimal,
        .srcQueueFamilyIndex = queueAllocation.m_Family,
        .dstQueueFamilyIndex = queueAllocation.m_Family,
        .subresourceRange = subresourceRange,
    };
    eastl::array postRenderBarriers = {
        renderToBlitBarrier,
        acquireToTransferDstBarrier,
    };
    vk::DependencyInfo postRenderDependencies = {
        .imageMemoryBarrierCount = Cast<u32>(postRenderBarriers.size()),
        .pImageMemoryBarriers = postRenderBarriers.data(),
    };

    vk::ImageMemoryBarrier2 transferDstToGuiRenderBarrier = {
        .srcStageMask = vk::PipelineStageFlagBits2::eAllTransfer,
        .srcAccessMask = vk::AccessFlagBits2::eTransferWrite,
        .dstStageMask = vk::PipelineStageFlagBits2::eColorAttachmentOutput,
        .dstAccessMask = vk::AccessFlagBits2::eColorAttachmentWrite,
        .oldLayout = vk::ImageLayout::eTransferDstOptimal,
        .newLayout = vk::ImageLayout::eColorAttachmentOptimal,
        .srcQueueFamilyIndex = queueAllocation.m_Family,
        .dstQueueFamilyIndex = queueAllocation.m_Family,
        .subresourceRange = subresourceRange,
    };
    vk::DependencyInfo preGuiDependencies = {
        .imageMemoryBarrierCount = 1,
        .pImageMemoryBarriers = &transferDstToGuiRenderBarrier,
    };

    vk::ImageMemoryBarrier2 prePresentBarrier = {
        .srcStageMask = vk::PipelineStageFlagBits2::eColorAttachmentOutput,
        .srcAccessMask = vk::AccessFlagBits2::eColorAttachmentWrite,
        .dstStageMask = vk::PipelineStageFlagBits2::eBottomOfPipe,
        .dstAccessMask = vk::AccessFlagBits2::eNone,
        .oldLayout = vk::ImageLayout::eColorAttachmentOptimal,
        .newLayout = vk::ImageLayout::ePresentSrcKHR,
        .srcQueueFamilyIndex = queueAllocation.m_Family,
        .dstQueueFamilyIndex = queueAllocation.m_Family,
        .subresourceRange = subresourceRange,
    };
    vk::DependencyInfo prePresentDependencies = {
        .imageMemoryBarrierCount = 1,
        .pImageMemoryBarriers = &prePresentBarrier,
    };

    FrameManager frameManager = {&device, queueAllocation.m_Family, MAX_FRAMES_IN_FLIGHT};
    eastl::fixed_vector<DepthImage, MAX_FRAMES_IN_FLIGHT> depthImages(frameManager.m_FramesInFlight);
    eastl::fixed_vector<AttachmentImage, MAX_FRAMES_IN_FLIGHT> attachmentImages(frameManager.m_FramesInFlight);
    {
        auto depthIter = depthImages.begin();
        auto attachmentIter = attachmentImages.begin();
        for (u32 index = 0; index < frameManager.m_FramesInFlight; ++index)
        {
            auto name = fmt::format("Depth Frame{}", index);
            depthIter->Init(&device, internalResolution, name.c_str());

            name = fmt::format("Attachment0 Frame{}", index);
            attachmentIter->Init(&device, internalResolution, attachmentFormat, name.c_str());

            ++depthIter;
            ++attachmentIter;
        }
    }

    struct NodeData
    {
        mat4 m_Transform;
        uptr m_VertexPositionPtr;
        uptr m_VertexDataPtr;
        uptr m_MaterialPtr;
        u8 m_Padding_[8];
    };

    eastl::vector<NodeData> nodeData;
    eastl::vector<vk::DrawIndexedIndirectCommand> nodeDrawInfo;

    eastl::fixed_vector<StorageBuffer, MAX_FRAMES_IN_FLIGHT> nodeBuffers;
    eastl::fixed_vector<IndirectBuffer, MAX_FRAMES_IN_FLIGHT> nodeIndirectBuffers;
    eastl::fixed_vector<uptr, MAX_FRAMES_IN_FLIGHT> perFrameNodeBufferPtr;

    for (u32 i = 0; i < frameManager.m_FramesInFlight; ++i)
    {
        auto *buffer = &nodeBuffers.push_back();
        buffer->Init(&device, sizeof(NodeData) * 100'000, true, true, "Node Buffer");
        auto *indirect = &nodeIndirectBuffers.push_back();
        indirect->Init(&device, sizeof(vk::DrawIndexedIndirectCommand) * 100'000, true);
        perFrameNodeBufferPtr.push_back(buffer->GetDeviceAddress(&device));
    }

    swapchain.RegisterResizeCallback(
        [&cameraController, &internalResolution, &viewport, &scissor](vk::Extent2D extent) {
            cameraController.SetAspectRatio(Cast<f32>(extent.width) / Cast<f32>(extent.height));

            internalResolution.width = Cast<u32>(Cast<f32>(internalResolution.height) * cameraController.m_AspectRatio);

            viewport.y = Cast<f32>(internalResolution.height);
            viewport.width = Cast<f32>(internalResolution.width);
            viewport.height = -Cast<f32>(internalResolution.height);
            scissor.extent = internalResolution;
        });

    auto sortByParentHier = [&registry](Entity a, Entity b) {
        const auto parent = registry.try_get<CParent<CDynamicTransform>>(b);
        return parent && parent->m_ParentEntity == a;
    };
    registry.sort<CParent<CDynamicTransform>>(sortByParentHier);

    Time::Init();

    auto rootNodeUpdateView = registry.view<CDynamicTransform, CGlobalTransform>(Without<CParent<CDynamicTransform>>{});

    auto rootModel = registry.group<CModel>(Get<CDynamicTransform>{});

    auto nodeWithParentsUpdateView = registry.view<CDynamicTransform, CParent<CDynamicTransform>, CGlobalTransform>();
    nodeWithParentsUpdateView.use<CParent<CDynamicTransform>>();

    auto renderableObjectsGroup = registry.group<CGlobalTransform, CMesh, CMaterial>();

    lightManager.Update();
    ubo.Write(&device, uboLightManagerOffset, sizeof lightManager.m_MetaInfo, &lightManager.m_MetaInfo);

    resourceManager.Update();

    while (window.Poll())
    {
        Time::Update();

        u32 index = 0;
        for (auto [entity, dynTrans] : rootModel.each())
        {
            dynTrans.m_Rotation =
                glm::rotate(dynTrans.m_Rotation, Cast<f32>(30_deg * (++index) * Time::m_Delta), vec3{0.0f, 1.0f, 0.0f});
        }

        Frame *currentFrame = frameManager.GetNextFrame(&swapchain, &window);

        u32 imageIndex = currentFrame->m_ImageIdx;
        vk::Image currentSwapchainImage = swapchain.m_Images[imageIndex];
        vk::ImageView currentSwapchainImageView = swapchain.m_ImageViews[imageIndex];
        vk::CommandBuffer cmd = currentFrame->m_CommandBuffer;

        DepthImage *currentDepthImage = &depthImages[currentFrame->m_FrameIdx];
        AttachmentImage *currentAttachment = &attachmentImages[currentFrame->m_FrameIdx];

        if (currentAttachment->m_Extent.width != internalResolution.width ||
            currentAttachment->m_Extent.height != internalResolution.height)
        {
            auto name = fmt::format("Depth Frame{}", currentFrame->m_FrameIdx);
            currentDepthImage->Destroy(&device);
            currentDepthImage->Init(&device, internalResolution, name.c_str());

            name = fmt::format("Attachment0 Frame{}", currentFrame->m_FrameIdx);
            currentAttachment->Destroy(&device);
            currentAttachment->Init(&device, internalResolution, attachmentFormat, name.c_str());
        }

        vk::ImageView currentDepthImageView = currentDepthImage->m_View;
        vk::Image currentImage = currentAttachment->m_Image;
        vk::ImageView currentImageView = currentAttachment->m_View;

        preRenderBarrier.image = currentImage;
        postRenderBarriers[0].image = currentImage;
        postRenderBarriers[1].image = currentSwapchainImage;
        transferDstToGuiRenderBarrier.image = currentSwapchainImage;
        prePresentBarrier.image = currentSwapchainImage;

        ubo.Write(&device, 0, sizeof cameraController.m_Camera, &cameraController.m_Camera);

        for (auto [entity, dynTransform, globalTransform] : rootNodeUpdateView.each())
        {
            auto scale = glm::scale(mat4{1.0f}, dynTransform.m_Scale);
            auto rotation = glm::toMat4(dynTransform.m_Rotation);
            auto translation = glm::translate(mat4{1.0f}, dynTransform.m_Position);

            globalTransform.m_Transform = translation * rotation * scale;
        }

        // Has been sorted and ordered by parent.
        for (auto [entity, dynTransform, parent, globalTransform] : nodeWithParentsUpdateView.each())
        {
            auto scale = glm::scale(mat4{1.0f}, dynTransform.m_Scale);
            auto rotation = glm::toMat4(dynTransform.m_Rotation);
            auto translation = glm::translate(mat4{1.0f}, dynTransform.m_Position);

            globalTransform.m_Transform =
                registry.get<CGlobalTransform>(parent.m_ParentEntity).m_Transform * translation * rotation * scale;
        }

        u32 objectCount = Cast<u32>(renderableObjectsGroup.size());
        nodeData.clear();
        nodeDrawInfo.clear();
        nodeData.reserve(objectCount);
        nodeDrawInfo.reserve(objectCount);
        for (auto [entity, globalTransform, mesh, material] : renderableObjectsGroup.each())
        {
            nodeData.push_back({
                .m_Transform = globalTransform.m_Transform,
                .m_VertexPositionPtr = mesh.m_VertexPositionPtr,
                .m_VertexDataPtr = mesh.m_VertexDataPtr,
                .m_MaterialPtr = material.m_MaterialPtr,
            });
            nodeDrawInfo.push_back({
                .indexCount = mesh.m_IndexCount,
                .instanceCount = 1,
                .firstIndex = mesh.m_FirstIndex,
                .vertexOffset = 0,
                .firstInstance = 0,
            });
        }

        nodeBuffers[currentFrame->m_FrameIdx].Write(&device, 0, objectCount * sizeof(NodeData), nodeData.data());
        nodeIndirectBuffers[currentFrame->m_FrameIdx].Write(&device, 0, objectCount * sizeof nodeDrawInfo[0],
                                                            nodeDrawInfo.data());

        vk::CommandBufferBeginInfo beginInfo = {.flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit};
        AbortIfFailed(cmd.begin(&beginInfo));

        cmd.pipelineBarrier2(&preRenderDependencies);

        // Render
        eastl::array attachmentInfos = {
            vk::RenderingAttachmentInfo{
                .imageView = currentImageView,
                .imageLayout = vk::ImageLayout::eColorAttachmentOptimal,
                .resolveMode = vk::ResolveModeFlagBits::eNone,
                .loadOp = vk::AttachmentLoadOp::eClear,
                .storeOp = vk::AttachmentStoreOp::eStore,
                .clearValue = vk::ClearColorValue{0.0f, 0.0f, 0.0f, 1.0f},
            },
        };

        vk::RenderingAttachmentInfo depthAttachment = {
            .imageView = currentDepthImageView,
            .imageLayout = vk::ImageLayout::eDepthAttachmentOptimal,
            .resolveMode = vk::ResolveModeFlagBits::eNone,
            .loadOp = vk::AttachmentLoadOp::eClear,
            .storeOp = vk::AttachmentStoreOp::eDontCare,
            .clearValue = vk::ClearDepthStencilValue{.depth = 1.0f, .stencil = 0},
        };

        vk::RenderingInfo renderingInfo = {
            .renderArea = {.extent = ToExtent2D(currentAttachment->m_Extent)},
            .layerCount = 1,
            .colorAttachmentCount = Cast<u32>(attachmentInfos.size()),
            .pColorAttachments = attachmentInfos.data(),
            .pDepthAttachment = &depthAttachment,
        };

        cmd.beginRendering(&renderingInfo);

        cmd.setViewport(0, 1, &viewport);
        cmd.setScissor(0, 1, &scissor);
        cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline.m_Layout, 0, 1,
                               &resourceManager.m_DescriptorSet, 0, nullptr);

        cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline.m_Layout, 1, 1, &perFrameDescriptor, 0,
                               nullptr);

        cmd.bindIndexBuffer(resourceManager.GetIndexBuffer(), 0, vk::IndexType::eUint32);

        cmd.bindPipeline(vk::PipelineBindPoint::eGraphics, pipeline.m_Pipeline);

        auto nodeBufferAddr = perFrameNodeBufferPtr[currentFrame->m_FrameIdx];

        cmd.pushConstants(pipeline.m_Layout, vk::ShaderStageFlagBits::eAll, 0, sizeof nodeBufferAddr, &nodeBufferAddr);

        cmd.drawIndexedIndirect(nodeIndirectBuffers[currentFrame->m_FrameIdx].m_Buffer, 0, objectCount,
                                sizeof nodeDrawInfo[0]);

        cmd.bindPipeline(vk::PipelineBindPoint::eGraphics, backgroundPipeline.m_Pipeline);

        cmd.draw(3, 1, 0, 0);

        cmd.endRendering();

        cmd.pipelineBarrier2(&postRenderDependencies);

        vk::ImageBlit blitRegion = {
            .srcSubresource =
                {
                    .aspectMask = vk::ImageAspectFlagBits::eColor,
                    .mipLevel = 0,
                    .baseArrayLayer = 0,
                    .layerCount = 1,
                },
            .srcOffsets =
                std::array{
                    vk::Offset3D{0, 0, 0},
                    ToOffset3D(currentAttachment->m_Extent),
                },
            .dstSubresource =
                {
                    .aspectMask = vk::ImageAspectFlagBits::eColor,
                    .mipLevel = 0,
                    .baseArrayLayer = 0,
                    .layerCount = 1,
                },
            .dstOffsets =
                std::array{
                    vk::Offset3D{0, 0, 0},
                    vk::Offset3D{Cast<i32>(swapchain.m_Extent.width), Cast<i32>(swapchain.m_Extent.height), 1},
                },
        };
        cmd.blitImage(currentImage, postRenderBarriers[0].newLayout, currentSwapchainImage,
                      postRenderBarriers[1].newLayout, 1, &blitRegion, vk::Filter::eLinear);

        cmd.pipelineBarrier2(&preGuiDependencies);

        cmd.pipelineBarrier2(&prePresentDependencies);

        AbortIfFailed(cmd.end());

        vk::PipelineStageFlags waitDstStage = vk::PipelineStageFlagBits::eColorAttachmentOutput;
        vk::SubmitInfo submitInfo = {
            .waitSemaphoreCount = 1,
            .pWaitSemaphores = &currentFrame->m_ImageAcquireSem,
            .pWaitDstStageMask = &waitDstStage,
            .commandBufferCount = 1,
            .pCommandBuffers = &cmd,
            .signalSemaphoreCount = 1,
            .pSignalSemaphores = &currentFrame->m_RenderFinishSem,
        };
        AbortIfFailed(graphicsQueue.submit(1, &submitInfo, currentFrame->m_FrameAvailableFence));

        currentFrame->Present(graphicsQueue, &swapchain, &window);
    }

    device.WaitIdle();

    for (auto buffer : nodeIndirectBuffers)
    {
        buffer.Destroy(&device);
    }
    for (auto buffer : nodeBuffers)
    {
        buffer.Destroy(&device);
    }
    for (auto depthImage : depthImages)
    {
        depthImage.Destroy(&device);
    }
    for (auto attachmentImage : attachmentImages)
    {
        attachmentImage.Destroy(&device);
    }
    ubo.Destroy(&device);

    device.m_Device.destroy(descriptorPool, nullptr);

    for (auto &model : models)
    {
        model.Destroy(&resourceManager, &registry);
    }
}