From f2bf5cad53a47afa4357e516d01d41d3eaca1c09 Mon Sep 17 00:00:00 2001 From: kj16609 Date: Thu, 11 Jul 2024 03:46:03 -0400 Subject: [PATCH] More cleanup --- shaders/gui-compose.frag | 4 +- src/engine/EngineContext.cpp | 12 ++-- src/engine/FrameInfo.hpp | 5 +- src/engine/gui/core.cpp | 3 +- src/engine/gui/preview.cpp | 16 +++-- src/engine/rendering/Renderer.cpp | 27 ++------ src/engine/rendering/Renderer.hpp | 14 ++-- src/engine/rendering/Subpass.hpp | 10 +-- src/engine/rendering/SwapChain.cpp | 104 ++++++++++++++++------------- src/engine/rendering/SwapChain.hpp | 51 ++++++-------- src/engine/rendering/types.hpp | 13 ++++ src/engine/systems/GuiSystem.cpp | 13 ++-- 12 files changed, 137 insertions(+), 135 deletions(-) create mode 100644 src/engine/rendering/types.hpp diff --git a/shaders/gui-compose.frag b/shaders/gui-compose.frag index 7eae4dc..d1ba96c 100644 --- a/shaders/gui-compose.frag +++ b/shaders/gui-compose.frag @@ -10,6 +10,4 @@ void main() { vec4 composite = subpassLoad(i_composite).xyzw; out_color = composite; -} - - +} \ No newline at end of file diff --git a/src/engine/EngineContext.cpp b/src/engine/EngineContext.cpp index 9c088c3..85c03a3 100644 --- a/src/engine/EngineContext.cpp +++ b/src/engine/EngineContext.cpp @@ -148,18 +148,18 @@ namespace fgl::engine camera_controller.moveInPlaneXZ( m_window.window(), delta_time, viewer ); camera.setView( viewer.getPosition(), viewer.getRotation() ); - if ( auto [ command_buffer, gui_command_buffer ] = m_renderer.beginFrame(); *command_buffer ) + if ( auto& command_buffer = m_renderer.beginFrame(); *command_buffer ) { ZoneScopedN( "Render" ); - //Update - const std::uint16_t frame_index { m_renderer.getFrameIndex() }; + const FrameIndex frame_index { m_renderer.getFrameIndex() }; + const PresentIndex present_idx { m_renderer.getPresentIndex() }; const auto view_frustum { camera.getFrustumBounds() }; FrameInfo frame_info { frame_index, + present_idx, delta_time, command_buffer, - gui_command_buffer, { camera, viewer.getTransform() }, global_descriptor_sets[ frame_index ], m_game_objects_root, @@ -168,8 +168,8 @@ namespace fgl::engine draw_parameter_buffers[ frame_index ], *this->m_vertex_buffer, *this->m_index_buffer, - m_renderer.getGBufferDescriptor( frame_index ), - m_renderer.getGBufferCompositeDescriptor( frame_index ), + m_renderer.getGBufferDescriptor( present_idx ), + m_renderer.getGBufferCompositeDescriptor( present_idx ), view_frustum, this->m_renderer.getSwapChain() }; diff --git a/src/engine/FrameInfo.hpp b/src/engine/FrameInfo.hpp index e042e49..214504c 100644 --- a/src/engine/FrameInfo.hpp +++ b/src/engine/FrameInfo.hpp @@ -15,6 +15,7 @@ #include "engine/descriptors/DescriptorSet.hpp" #include "engine/descriptors/DescriptorSetLayout.hpp" #include "engine/tree/octtree/OctTreeNode.hpp" +#include "rendering/types.hpp" #define MAX_LIGHTS 10 @@ -75,11 +76,11 @@ namespace fgl::engine struct FrameInfo { - std::uint16_t frame_idx; + FrameIndex frame_idx; + PresentIndex present_idx; float frame_time; vk::raii::CommandBuffer& command_buffer; - vk::raii::CommandBuffer& gui_command_buffer; struct { diff --git a/src/engine/gui/core.cpp b/src/engine/gui/core.cpp index 091e370..7bac810 100644 --- a/src/engine/gui/core.cpp +++ b/src/engine/gui/core.cpp @@ -136,7 +136,6 @@ namespace fgl::engine::gui void drawMainGUI( FrameInfo& info ) { ZoneScoped; - TracyVkZone( info.tracy_ctx, *info.gui_command_buffer, "ImGui Rendering" ); beginImGui(); // TODO: Maybe play with docks again some other time @@ -148,7 +147,7 @@ namespace fgl::engine::gui drawEntityInfo( info ); drawFilesystemGUI( info ); - endImGui( info.gui_command_buffer ); + endImGui( info.command_buffer ); } static GameObject* selected_object { nullptr }; diff --git a/src/engine/gui/preview.cpp b/src/engine/gui/preview.cpp index 81eed25..df06c90 100644 --- a/src/engine/gui/preview.cpp +++ b/src/engine/gui/preview.cpp @@ -98,6 +98,8 @@ namespace fgl::engine::gui void drawRenderingOutputs( FrameInfo& info ) { ZoneScoped; + const auto present_idx { info.present_idx }; + ImGui::Begin( "RenderOutputs" ); enum RenderingOutputSelection : std::uint_fast8_t @@ -139,7 +141,7 @@ namespace fgl::engine::gui current = Composite; } - info.swap_chain.g_buffer_albedo_img->drawImGui( { v_size, h_size } ); + info.swap_chain.g_buffer_albedo_img[ present_idx ]->drawImGui( { v_size, h_size } ); ImGui::SameLine(); if ( ImGui::Selectable( options[ Albedo ], current == Albedo ) ) { @@ -147,7 +149,7 @@ namespace fgl::engine::gui current = Albedo; } - info.swap_chain.g_buffer_normal_img->drawImGui( { v_size, h_size } ); + info.swap_chain.g_buffer_normal_img[ present_idx ]->drawImGui( { v_size, h_size } ); ImGui::SameLine(); if ( ImGui::Selectable( options[ Normal ], current == Normal ) ) { @@ -155,7 +157,7 @@ namespace fgl::engine::gui current = Normal; } - info.swap_chain.g_buffer_position_img->drawImGui( { v_size, h_size } ); + info.swap_chain.g_buffer_position_img[ present_idx ]->drawImGui( { v_size, h_size } ); ImGui::SameLine(); if ( ImGui::Selectable( options[ Position ], current == Position ) ) { @@ -171,16 +173,16 @@ namespace fgl::engine::gui default: [[fallthrough]]; case Composite: - info.swap_chain.g_buffer_composite_img->drawImGui(); + info.swap_chain.g_buffer_composite_img[ present_idx ]->drawImGui(); break; case Albedo: - info.swap_chain.g_buffer_albedo_img->drawImGui(); + info.swap_chain.g_buffer_albedo_img[ present_idx ]->drawImGui(); break; case Normal: - info.swap_chain.g_buffer_normal_img->drawImGui(); + info.swap_chain.g_buffer_normal_img[ present_idx ]->drawImGui(); break; case Position: - info.swap_chain.g_buffer_position_img->drawImGui(); + info.swap_chain.g_buffer_position_img[ present_idx ]->drawImGui(); break; } diff --git a/src/engine/rendering/Renderer.cpp b/src/engine/rendering/Renderer.cpp index b782e44..f0ae9d2 100644 --- a/src/engine/rendering/Renderer.cpp +++ b/src/engine/rendering/Renderer.cpp @@ -97,11 +97,11 @@ namespace fgl::engine } } - std::pair< vk::raii::CommandBuffer&, vk::raii::CommandBuffer& > Renderer::beginFrame() + vk::raii::CommandBuffer& Renderer::beginFrame() { assert( !is_frame_started && "Cannot begin frame while frame is already in progress" ); - auto [ result, image_idx ] = m_swapchain->acquireNextImage(); - current_image_idx = image_idx; + auto [ result, present_index ] = m_swapchain->acquireNextImage(); + current_present_index = present_index; if ( result == vk::Result::eErrorOutOfDateKHR ) { @@ -113,7 +113,6 @@ namespace fgl::engine is_frame_started = true; auto& command_buffer { getCurrentCommandbuffer() }; - auto& gui_command_buffer { getCurrentGuiCommandBuffer() }; vk::CommandBufferBeginInfo begin_info {}; begin_info.pNext = VK_NULL_HANDLE; @@ -122,21 +121,7 @@ namespace fgl::engine command_buffer.begin( begin_info ); - vk::CommandBufferInheritanceInfo inheritance_info {}; - inheritance_info.framebuffer = this->getSwapChain().getFrameBuffer( current_image_idx ); - inheritance_info.renderPass = this->getSwapChainRenderPass(); - inheritance_info.subpass = 2; - - vk::CommandBufferBeginInfo gui_begin_info {}; - gui_begin_info.pInheritanceInfo = &inheritance_info; - gui_begin_info.flags = vk::CommandBufferUsageFlagBits::eRenderPassContinue; - - gui_command_buffer.begin( gui_begin_info ); - - setViewport( gui_command_buffer ); - setScissor( gui_command_buffer ); - - return { command_buffer, gui_command_buffer }; + return command_buffer; } void Renderer::endFrame() @@ -148,7 +133,7 @@ namespace fgl::engine command_buffer.end(); - const auto result { m_swapchain->submitCommandBuffers( command_buffer, current_image_idx ) }; + const auto result { m_swapchain->submitCommandBuffers( command_buffer, current_present_index ) }; if ( result == vk::Result::eErrorOutOfDateKHR || result == vk::Result::eSuboptimalKHR || m_window.wasWindowResized() ) @@ -196,7 +181,7 @@ namespace fgl::engine vk::RenderPassBeginInfo render_pass_info {}; render_pass_info.pNext = VK_NULL_HANDLE; render_pass_info.renderPass = m_swapchain->getRenderPass(); - render_pass_info.framebuffer = m_swapchain->getFrameBuffer( static_cast< int >( current_image_idx ) ); + render_pass_info.framebuffer = m_swapchain->getFrameBuffer( current_present_index ); render_pass_info.renderArea = { .offset = { 0, 0 }, .extent = m_swapchain->getSwapChainExtent() }; render_pass_info.clearValueCount = static_cast< std::uint32_t >( clear_values.size() ); render_pass_info.pClearValues = clear_values.data(); diff --git a/src/engine/rendering/Renderer.hpp b/src/engine/rendering/Renderer.hpp index 995fcfb..17c7217 100644 --- a/src/engine/rendering/Renderer.hpp +++ b/src/engine/rendering/Renderer.hpp @@ -32,8 +32,8 @@ namespace fgl::engine std::optional< TracyVkCtx > m_tracy_ctx { std::nullopt }; - uint32_t current_image_idx { std::numeric_limits< std::uint32_t >::max() }; - std::uint16_t current_frame_idx { 0 }; + PresentIndex current_present_index { std::numeric_limits< PresentIndex >::max() }; + FrameIndex current_frame_idx { 0 }; bool is_frame_started { false }; void createCommandBuffers(); @@ -51,12 +51,18 @@ namespace fgl::engine return m_swapchain->getGBufferCompositeDescriptor( frame_idx ); } - std::uint16_t getFrameIndex() const + FrameIndex getFrameIndex() const { assert( is_frame_started && "Cannot get frame index while frame not in progress" ); return current_frame_idx; } + PresentIndex getPresentIndex() const + { + assert( current_present_index != std::numeric_limits< PresentIndex >::max() ); + return current_present_index; + } + bool isFrameInProgress() const { return is_frame_started; } vk::raii::CommandBuffer& getCurrentCommandbuffer() @@ -81,7 +87,7 @@ namespace fgl::engine float getAspectRatio() const { return m_swapchain->extentAspectRatio(); } - std::pair< vk::raii::CommandBuffer&, vk::raii::CommandBuffer& > beginFrame(); + vk::raii::CommandBuffer& beginFrame(); void endFrame(); void setViewport( const vk::raii::CommandBuffer& buffer ); diff --git a/src/engine/rendering/Subpass.hpp b/src/engine/rendering/Subpass.hpp index 5b0218f..9df1cfc 100644 --- a/src/engine/rendering/Subpass.hpp +++ b/src/engine/rendering/Subpass.hpp @@ -199,17 +199,17 @@ namespace fgl::engine void registerDependencyToExternal( const vk::AccessFlags src_access_flags, const vk::PipelineStageFlags src_stage_flags, - const vk::AccessFlags dst_access_flags, - const vk::PipelineStageFlags dst_stage_flags, - const vk::DependencyFlags dependency_flags ) + const vk::AccessFlags dst_access_flags = vk::AccessFlagBits::eNone, + const vk::PipelineStageFlags dst_stage_flags = vk::PipelineStageFlagBits::eNone, + const vk::DependencyFlags dependency_flags = {} ) { registerDependency( this->getIndex(), VK_SUBPASS_EXTERNAL, src_access_flags, src_stage_flags, - dst_access_flags, - dst_stage_flags, + dst_access_flags == vk::AccessFlagBits::eNone ? src_access_flags : dst_access_flags, + dst_stage_flags == vk::PipelineStageFlagBits::eNone ? src_stage_flags : dst_stage_flags, dependency_flags ); } }; diff --git a/src/engine/rendering/SwapChain.cpp b/src/engine/rendering/SwapChain.cpp index 2907acc..8fb5411 100644 --- a/src/engine/rendering/SwapChain.cpp +++ b/src/engine/rendering/SwapChain.cpp @@ -15,7 +15,7 @@ namespace fgl::engine { - SwapChain::SwapChain( vk::Extent2D extent, PhysicalDevice& phy_device ) : + SwapChain::SwapChain( const vk::Extent2D extent, PhysicalDevice& phy_device ) : m_phy_device( phy_device ), m_swapchain_details( Device::getInstance().getSwapChainSupport() ), m_surface_format( chooseSwapSurfaceFormat( m_swapchain_details.formats ) ), @@ -37,12 +37,12 @@ namespace fgl::engine gbuffer.albedo, gbuffer.composite ) ), m_gbuffer_descriptor_set( createGBufferDescriptors() ), - m_gbuffer_composite_descriptor_set( createCompositeDescriptors() ) + m_composite_descriptor_set( createCompositeDescriptors() ) { init(); } - SwapChain::SwapChain( vk::Extent2D extent, std::shared_ptr< SwapChain > previous ) : + SwapChain::SwapChain( const vk::Extent2D extent, std::shared_ptr< SwapChain > previous ) : m_phy_device( previous->m_phy_device ), m_swapchain_details( Device::getInstance().getSwapChainSupport() ), m_surface_format( chooseSwapSurfaceFormat( m_swapchain_details.formats ) ), @@ -64,7 +64,7 @@ namespace fgl::engine gbuffer.albedo, gbuffer.composite ) ), m_gbuffer_descriptor_set( createGBufferDescriptors() ), - m_gbuffer_composite_descriptor_set( createCompositeDescriptors() ) + m_composite_descriptor_set( createCompositeDescriptors() ) { init(); old_swap_chain.reset(); @@ -75,7 +75,7 @@ namespace fgl::engine createSyncObjects(); } - std::pair< vk::Result, std::uint32_t > SwapChain::acquireNextImage() + std::pair< vk::Result, PresentIndex > SwapChain::acquireNextImage() { ZoneScoped; @@ -93,13 +93,14 @@ namespace fgl::engine return result; } - vk::Result SwapChain::submitCommandBuffers( const vk::raii::CommandBuffer& buffers, std::uint32_t imageIndex ) + vk::Result SwapChain:: + submitCommandBuffers( const vk::raii::CommandBuffer& buffers, const PresentIndex present_index ) { ZoneScoped; - images_in_flight[ imageIndex ] = in_flight_fence[ m_current_frame_index ]; + images_in_flight[ present_index ] = in_flight_fence[ m_current_frame_index ]; - std::vector< vk::Fence > fences { images_in_flight[ imageIndex ] }; + std::vector< vk::Fence > fences { images_in_flight[ present_index ] }; if ( Device::getInstance().device().waitForFences( fences, VK_TRUE, std::numeric_limits< uint64_t >::max() ) != vk::Result::eSuccess ) @@ -135,7 +136,7 @@ namespace fgl::engine std::vector< vk::SwapchainKHR > swapchains { m_swapchain }; presentInfo.setSwapchains( swapchains ); - std::array< std::uint32_t, 1 > indicies { { imageIndex } }; + std::array< std::uint32_t, 1 > indicies { { present_index } }; presentInfo.setImageIndices( indicies ); if ( auto present_result = Device::getInstance().presentQueue().presentKHR( presentInfo ); @@ -254,14 +255,11 @@ namespace fgl::engine Subpass< vk::PipelineBindPoint::eGraphics, - UsedAttachment< DepthAttachment, vk::ImageLayout::eDepthStencilAttachmentOptimal >, UsedAttachment< ColorAttachment, vk::ImageLayout::eColorAttachmentOptimal >, InputAttachment< ColorAttachment, vk::ImageLayout::eShaderReadOnlyOptimal >, InputAttachment< ColorAttachment, vk::ImageLayout::eShaderReadOnlyOptimal >, InputAttachment< ColorAttachment, vk::ImageLayout::eShaderReadOnlyOptimal > > - composite_subpass { - 1, render_attachments.depth, gbuffer.composite, gbuffer.position, gbuffer.normal, gbuffer.albedo - }; + composite_subpass { 1, gbuffer.composite, gbuffer.position, gbuffer.normal, gbuffer.albedo }; composite_subpass.registerDependencyFromExternal( vk::AccessFlagBits::eColorAttachmentWrite, vk::PipelineStageFlagBits::eColorAttachmentOutput ); @@ -275,14 +273,11 @@ namespace fgl::engine vk::PipelineStageFlagBits::eFragmentShader, vk::DependencyFlagBits::eByRegion ); - // For depth attachment - composite_subpass.registerDependencyFrom( - g_buffer_subpass, - vk::AccessFlagBits::eDepthStencilAttachmentWrite, - vk::PipelineStageFlagBits::eEarlyFragmentTests | vk::PipelineStageFlagBits::eLateFragmentTests, - vk::AccessFlagBits::eDepthStencilAttachmentRead | vk::AccessFlagBits::eDepthStencilAttachmentWrite, - vk::PipelineStageFlagBits::eEarlyFragmentTests | vk::PipelineStageFlagBits::eLateFragmentTests, - vk::DependencyFlagBits::eByRegion ); + composite_subpass.registerDependencyToExternal( + vk::AccessFlagBits::eColorAttachmentWrite, + vk::PipelineStageFlagBits::eColorAttachmentOutput, + vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eInputAttachmentRead, + vk::PipelineStageFlagBits::eFragmentShader ); // To prevent the composite buffer from getting obliterated by the gui pass and so we can use it to render to the GUI in certian areas, We need to keep them seperate and the composite image to be unmodified. Subpass< @@ -292,6 +287,17 @@ namespace fgl::engine InputAttachment< ColorAttachment, vk::ImageLayout::eShaderReadOnlyOptimal > > gui_subpass { 2, render_attachments.depth, render_attachments.color, gbuffer.composite }; + gui_subpass.registerFullDependency( composite_subpass ); + + // For depth attachment + gui_subpass.registerDependencyFrom( + g_buffer_subpass, + vk::AccessFlagBits::eDepthStencilAttachmentWrite, + vk::PipelineStageFlagBits::eEarlyFragmentTests | vk::PipelineStageFlagBits::eLateFragmentTests, + vk::AccessFlagBits::eDepthStencilAttachmentRead | vk::AccessFlagBits::eDepthStencilAttachmentWrite, + vk::PipelineStageFlagBits::eEarlyFragmentTests | vk::PipelineStageFlagBits::eLateFragmentTests, + vk::DependencyFlagBits::eByRegion ); + gui_subpass.registerDependencyFromExternal( vk::AccessFlagBits::eColorAttachmentWrite, vk::PipelineStageFlagBits::eColorAttachmentOutput ); @@ -299,7 +305,7 @@ namespace fgl::engine composite_subpass, vk::AccessFlagBits::eColorAttachmentWrite, vk::PipelineStageFlagBits::eColorAttachmentOutput, - vk::AccessFlagBits::eShaderRead, + vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eInputAttachmentRead, vk::PipelineStageFlagBits::eFragmentShader, vk::DependencyFlagBits::eByRegion ); @@ -312,18 +318,12 @@ namespace fgl::engine vk::DependencyFlagBits::eByRegion ); gui_subpass.registerDependencyToExternal( - vk::AccessFlagBits::eColorAttachmentWrite, - vk::PipelineStageFlagBits::eColorAttachmentOutput, - vk::AccessFlagBits::eMemoryRead, - vk::PipelineStageFlagBits::eBottomOfPipe, - vk::DependencyFlagBits::eByRegion ); + vk::AccessFlagBits::eColorAttachmentWrite, vk::PipelineStageFlagBits::eColorAttachmentOutput ); render_pass_builder.registerSubpass( g_buffer_subpass ); render_pass_builder.registerSubpass( composite_subpass ); render_pass_builder.registerSubpass( gui_subpass ); - m_clear_values = render_pass_builder.getClearValues(); - return render_pass_builder.create(); } @@ -338,23 +338,31 @@ namespace fgl::engine gbuffer.position.createResourceSpread( imageCount(), getSwapChainExtent(), vk::ImageUsageFlagBits::eSampled ); gbuffer.position.setClear( vk::ClearColorValue( std::array< float, 4 > { { 0.0f, 0.0f, 0.0f, 0.0f } } ) ); - g_buffer_position_img = std::make_unique< Texture >( gbuffer.position.m_attachment_resources.m_images[ 0 ] - ->setName( "GBufferPosition" ) ); gbuffer.normal.createResourceSpread( imageCount(), getSwapChainExtent(), vk::ImageUsageFlagBits::eSampled ); gbuffer.normal.setClear( vk::ClearColorValue( std::array< float, 4 > { { 0.0f, 0.0f, 0.0f, 0.0f } } ) ); - g_buffer_normal_img = std::make_unique< Texture >( gbuffer.normal.m_attachment_resources.m_images[ 0 ] - ->setName( "GBufferNormal" ) ); gbuffer.albedo.createResourceSpread( imageCount(), getSwapChainExtent(), vk::ImageUsageFlagBits::eSampled ); gbuffer.albedo.setClear( vk::ClearColorValue( std::array< float, 4 > { { 0.0f, 0.0f, 0.0f, 0.0f } } ) ); - g_buffer_albedo_img = std::make_unique< Texture >( gbuffer.albedo.m_attachment_resources.m_images[ 0 ] - ->setName( "GBufferAlbedo" ) ); gbuffer.composite.createResourceSpread( imageCount(), getSwapChainExtent(), vk::ImageUsageFlagBits::eSampled ); gbuffer.composite.setClear( vk::ClearColorValue( std::array< float, 4 > { { 0.0f, 0.0f, 0.0f, 0.0f } } ) ); - g_buffer_composite_img = std::make_unique< Texture >( gbuffer.composite.m_attachment_resources.m_images[ 0 ] - ->setName( "GBufferComposite" ) ); + + for ( PresentIndex i = 0; i < imageCount(); ++i ) + { + g_buffer_position_img.emplace_back( std::make_unique< Texture >( gbuffer.position.m_attachment_resources + .m_images[ i ] + ->setName( "GBufferPosition" ) ) ); + g_buffer_normal_img.emplace_back( std::make_unique< Texture >( gbuffer.normal.m_attachment_resources + .m_images[ i ] + ->setName( "GBufferNormal" ) ) ); + g_buffer_albedo_img.emplace_back( std::make_unique< Texture >( gbuffer.albedo.m_attachment_resources + .m_images[ i ] + ->setName( "GBufferAlbedo" ) ) ); + g_buffer_composite_img.emplace_back( std::make_unique< Texture >( gbuffer.composite.m_attachment_resources + .m_images[ i ] + ->setName( "GBufferComposite" ) ) ); + } std::vector< vk::raii::Framebuffer > framebuffers {}; @@ -390,9 +398,9 @@ namespace fgl::engine void SwapChain::createSyncObjects() { ZoneScoped; - image_available_sem.reserve( MAX_FRAMES_IN_FLIGHT ); - render_finished_sem.reserve( MAX_FRAMES_IN_FLIGHT ); - in_flight_fence.reserve( MAX_FRAMES_IN_FLIGHT ); + image_available_sem.reserve( imageCount() ); + render_finished_sem.reserve( imageCount() ); + in_flight_fence.reserve( imageCount() ); images_in_flight.resize( imageCount(), VK_NULL_HANDLE ); vk::SemaphoreCreateInfo semaphoreInfo {}; @@ -488,12 +496,12 @@ namespace fgl::engine } } - std::array< std::unique_ptr< descriptors::DescriptorSet >, SwapChain::MAX_FRAMES_IN_FLIGHT > SwapChain:: - createGBufferDescriptors() + std::vector< std::unique_ptr< descriptors::DescriptorSet > > SwapChain::createGBufferDescriptors() { - std::array< std::unique_ptr< descriptors::DescriptorSet >, SwapChain::MAX_FRAMES_IN_FLIGHT > data; + std::vector< std::unique_ptr< descriptors::DescriptorSet > > data; + data.resize( imageCount() ); - for ( int i = 0; i < SwapChain::MAX_FRAMES_IN_FLIGHT; ++i ) + for ( PresentIndex i = 0; i < imageCount(); ++i ) { auto set { std::make_unique< descriptors::DescriptorSet >( GBufferDescriptorSet::createLayout() ) }; @@ -513,12 +521,12 @@ namespace fgl::engine return data; } - std::array< std::unique_ptr< descriptors::DescriptorSet >, SwapChain::MAX_FRAMES_IN_FLIGHT > SwapChain:: - createCompositeDescriptors() + std::vector< std::unique_ptr< descriptors::DescriptorSet > > SwapChain::createCompositeDescriptors() { - std::array< std::unique_ptr< descriptors::DescriptorSet >, SwapChain::MAX_FRAMES_IN_FLIGHT > data; + std::vector< std::unique_ptr< descriptors::DescriptorSet > > data; + data.resize( imageCount() ); - for ( int i = 0; i < SwapChain::MAX_FRAMES_IN_FLIGHT; ++i ) + for ( PresentIndex i = 0; i < imageCount(); ++i ) { auto composite_set { std::make_unique< descriptors::DescriptorSet >( GBufferCompositeDescriptorSet::createLayout() ) diff --git a/src/engine/rendering/SwapChain.hpp b/src/engine/rendering/SwapChain.hpp index fd5a068..1f7149a 100644 --- a/src/engine/rendering/SwapChain.hpp +++ b/src/engine/rendering/SwapChain.hpp @@ -1,7 +1,5 @@ #pragma once -#include - #include #include @@ -9,6 +7,7 @@ #include "RenderPassBuilder.hpp" #include "engine/FrameInfo.hpp" #include "engine/texture/Texture.hpp" +#include "types.hpp" namespace fgl::engine { @@ -16,7 +15,7 @@ namespace fgl::engine { public: - static constexpr std::uint16_t MAX_FRAMES_IN_FLIGHT = 2; + static constexpr std::uint16_t MAX_FRAMES_IN_FLIGHT { 2 }; private: @@ -51,10 +50,10 @@ namespace fgl::engine public: - std::unique_ptr< Texture > g_buffer_position_img { nullptr }; - std::unique_ptr< Texture > g_buffer_normal_img { nullptr }; - std::unique_ptr< Texture > g_buffer_albedo_img { nullptr }; - std::unique_ptr< Texture > g_buffer_composite_img { nullptr }; + std::vector< std::unique_ptr< Texture > > g_buffer_position_img {}; + std::vector< std::unique_ptr< Texture > > g_buffer_normal_img {}; + std::vector< std::unique_ptr< Texture > > g_buffer_albedo_img {}; + std::vector< std::unique_ptr< Texture > > g_buffer_composite_img {}; private: @@ -66,11 +65,9 @@ namespace fgl::engine std::vector< vk::ClearValue > m_clear_values; - std::array< std::unique_ptr< descriptors::DescriptorSet >, SwapChain::MAX_FRAMES_IN_FLIGHT > - m_gbuffer_descriptor_set; + std::vector< std::unique_ptr< descriptors::DescriptorSet > > m_gbuffer_descriptor_set; - std::array< std::unique_ptr< descriptors::DescriptorSet >, SwapChain::MAX_FRAMES_IN_FLIGHT > - m_gbuffer_composite_descriptor_set; + std::vector< std::unique_ptr< descriptors::DescriptorSet > > m_composite_descriptor_set; std::vector< vk::raii::Semaphore > image_available_sem {}; std::vector< vk::raii::Semaphore > render_finished_sem {}; @@ -113,29 +110,25 @@ namespace fgl::engine return clear_values; } - std::array< std::unique_ptr< descriptors::DescriptorSet >, SwapChain::MAX_FRAMES_IN_FLIGHT > - createGBufferDescriptors(); - std::array< std::unique_ptr< descriptors::DescriptorSet >, SwapChain::MAX_FRAMES_IN_FLIGHT > - createCompositeDescriptors(); + std::vector< std::unique_ptr< descriptors::DescriptorSet > > createGBufferDescriptors(); + std::vector< std::unique_ptr< descriptors::DescriptorSet > > createCompositeDescriptors(); public: std::vector< vk::ClearValue > getClearValues() const { return m_clear_values; } - descriptors::DescriptorSet& getGBufferDescriptor( std::uint16_t frame_idx ) const + descriptors::DescriptorSet& getGBufferDescriptor( PresentIndex frame_idx ) const { - assert( frame_idx < SwapChain::MAX_FRAMES_IN_FLIGHT && "Frame index out of range" ); - assert( - m_gbuffer_descriptor_set.size() == SwapChain::MAX_FRAMES_IN_FLIGHT - && "GBuffer descriptor set not initialized" ); + assert( frame_idx < imageCount() && "Frame index out of range" ); + assert( m_gbuffer_descriptor_set.size() > 0 && "GBuffer descriptor set not initialized" ); return *m_gbuffer_descriptor_set[ frame_idx ]; } - descriptors::DescriptorSet& getGBufferCompositeDescriptor( uint16_t frame_idx ) const + descriptors::DescriptorSet& getGBufferCompositeDescriptor( PresentIndex frame_idx ) const { - assert( frame_idx < SwapChain::MAX_FRAMES_IN_FLIGHT && "Frame index out of range" ); - - return *m_gbuffer_composite_descriptor_set[ frame_idx ]; + assert( frame_idx < imageCount() && "Frame index out of range" ); + assert( m_composite_descriptor_set.size() > 0 && "GBuffer descriptor set not initialized" ); + return *m_composite_descriptor_set[ frame_idx ]; } SwapChain( vk::Extent2D windowExtent, PhysicalDevice& phy_dev ); @@ -144,14 +137,14 @@ namespace fgl::engine SwapChain( const SwapChain& ) = delete; SwapChain& operator=( const SwapChain& ) = delete; - vk::raii::Framebuffer& getFrameBuffer( std::uint32_t index ) + vk::raii::Framebuffer& getFrameBuffer( const PresentIndex present_index ) { - return m_swap_chain_buffers[ static_cast< std::size_t >( index ) ]; + return m_swap_chain_buffers[ static_cast< std::size_t >( present_index ) ]; } vk::raii::RenderPass& getRenderPass() { return m_render_pass; } - std::uint16_t imageCount() const { return static_cast< std::uint16_t >( m_swap_chain_images.size() ); } + PresentIndex imageCount() const { return static_cast< std::uint16_t >( m_swap_chain_images.size() ); } vk::Format getSwapChainImageFormat() const { return m_swap_chain_format; } @@ -174,9 +167,9 @@ namespace fgl::engine static vk::Format findDepthFormat(); - [[nodiscard]] std::pair< vk::Result, std::uint32_t > acquireNextImage(); + [[nodiscard]] std::pair< vk::Result, PresentIndex > acquireNextImage(); [[nodiscard]] vk::Result - submitCommandBuffers( const vk::raii::CommandBuffer& buffers, std::uint32_t imageIndex ); + submitCommandBuffers( const vk::raii::CommandBuffer& buffers, PresentIndex present_index ); }; } // namespace fgl::engine diff --git a/src/engine/rendering/types.hpp b/src/engine/rendering/types.hpp new file mode 100644 index 0000000..5f919dc --- /dev/null +++ b/src/engine/rendering/types.hpp @@ -0,0 +1,13 @@ +// +// Created by kj16609 on 7/11/24. +// + +#pragma once + +#include + +namespace fgl::engine +{ + using PresentIndex = std::uint16_t; + using FrameIndex = std::uint16_t; +} diff --git a/src/engine/systems/GuiSystem.cpp b/src/engine/systems/GuiSystem.cpp index 42d9399..256a6b0 100644 --- a/src/engine/systems/GuiSystem.cpp +++ b/src/engine/systems/GuiSystem.cpp @@ -24,13 +24,15 @@ namespace fgl::engine vk::raii::CommandBuffer& GuiSystem::setupSystem( FrameInfo& info ) { - auto& command_buffer { info.gui_command_buffer }; + auto& command_buffer { info.command_buffer }; + + command_buffer.nextSubpass( vk::SubpassContents::eInline ); + + m_pipeline->bind( command_buffer ); m_pipeline ->bindDescriptor( command_buffer, GBufferCompositeDescriptorSet::m_set_idx, info.gbuffer_composite_set ); - m_pipeline->bind( command_buffer ); - return command_buffer; } @@ -42,11 +44,6 @@ namespace fgl::engine //Handle GUI gui::drawMainGUI( info ); - - command_buffer.end(); - - info.command_buffer.nextSubpass( vk::SubpassContents::eSecondaryCommandBuffers ); - info.command_buffer.executeCommands( { info.gui_command_buffer } ); } } // namespace fgl::engine