KJ16609/FGL-Engine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

More cleanup

Browse Source
This commit is contained in:
kj16609
2024-07-11 03:46:03 -04:00
parent 2f7e3452ac
commit f2bf5cad53
12 changed files with 137 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
shaders/gui-compose.frag
View File

@@ -10,6 +10,4 @@ void main() {
vec4 composite = subpassLoad(i_composite).xyzw;
out_color = composite;
}
}

12
src/engine/EngineContext.cpp
View File

@@ -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() };

5
src/engine/FrameInfo.hpp
View File

@@ -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
{

3
src/engine/gui/core.cpp
View File

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

16
src/engine/gui/preview.cpp
View File

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

27
src/engine/rendering/Renderer.cpp
View File

@@ -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();

14
src/engine/rendering/Renderer.hpp
View File

@@ -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 );

10
src/engine/rendering/Subpass.hpp
View File

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

104
src/engine/rendering/SwapChain.cpp
View File

@@ -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() )

51
src/engine/rendering/SwapChain.hpp
View File

@@ -1,7 +1,5 @@
#pragma once
#include <vulkan/vulkan.h>
#include <memory>
#include <vector>
@@ -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

13
src/engine/rendering/types.hpp Normal file
View File

@@ -0,0 +1,13 @@
//
// Created by kj16609 on 7/11/24.
//
#pragma once
#include <cstdint>
namespace fgl::engine
{
using PresentIndex = std::uint16_t;
using FrameIndex = std::uint16_t;
}

13
src/engine/systems/GuiSystem.cpp
View File

@@ -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