void VulkanEngine::initRenderPasses()
{
    RenderPass gBuffer = Builders::buildGBufferRenderPass(m_device, {
                                                                        {VK_FORMAT_R8G8B8A8_UNORM,      VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL},
                                                                        {VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL},
                                                                        {VK_FORMAT_R16G16B16A16_SFLOAT, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL}
                                                                    });
    std::vector<VkImageView> views;

    for (auto attachment : m_gBuffer)
        views.push_back(attachment.view);

    views.push_back(m_depthImage.view);

    gBuffer.framebuffers.push_back(Builders::createFrameBuffer(m_device, c_windowSize, gBuffer.pass, views));

    //---------------------------------------------------------------------------------------------------

    RenderPass deferredPBR = Builders::buildDeferredPBRRenderPass(m_device, m_swapchainFormat);

    for (const auto& swapchainImage : m_swapchainImageViews)
        deferredPBR.framebuffers.push_back(Builders::createFrameBuffer(m_device, c_windowSize, deferredPBR.pass, {swapchainImage}));

    m_renderPasses = {gBuffer, deferredPBR};
}

void VulkanEngine::initPipelines()
{
    Pipeline gBuffer = Builders::buildGBufferPipeline(m_device,
                                                      c_windowSize,
                                                      m_gBuffer.size(),
                                                      m_renderPasses.at(0).pass,
                                                      {
                                                          m_globalSetLayout,
                                                          m_textureSetLayout
                                                      },
                                                      Mesh::getVertexInputDescription(),
                                                      {
                                                         {"GBuffer.v.spv", VK_SHADER_STAGE_VERTEX_BIT},
                                                         {"GBuffer.g.spv", VK_SHADER_STAGE_GEOMETRY_BIT},
                                                         {"GBuffer.f.spv", VK_SHADER_STAGE_FRAGMENT_BIT}
                                                      });

    Pipeline deferredPBR = Builders::buildDeferredPBRPipeline(m_device,
                                                           c_windowSize,
                                                           m_renderPasses.at(1).pass,
                                                           {
                                                               m_globalSetLayout,
                                                               m_gBufferSetLayout
                                                           },
                                                           {
                                                              {"PBR.v.spv", VK_SHADER_STAGE_VERTEX_BIT},
                                                              {"PBR.f.spv", VK_SHADER_STAGE_FRAGMENT_BIT}
                                                           });

    m_pipelines = {gBuffer, deferredPBR};
}