kbz_8/MacroLibX
1
0
Fork 0
mirror of https://github.com/seekrs/MacroLibX.git synced 2026-01-11 22:53:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

adding shaders compilation in makefile

Browse Source
This commit is contained in:
Kbz-8
2024-09-22 21:39:20 +02:00
parent c718915927
commit cf773b586e
27 changed files with 415 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
runtime/Sources/Renderer/Buffer.cpp
View File

@@ -46,6 +46,7 @@ namespace mlx
bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
#ifdef DEBUG
m_debug_name = debug_name;
std::string alloc_name{ debug_name };
if(usage & VK_BUFFER_USAGE_INDEX_BUFFER_BIT)
alloc_name.append("_index_buffer");
@@ -56,7 +57,6 @@ namespace mlx
else
alloc_name.append("_buffer");
m_allocation = RenderCore::Get().GetAllocator().CreateBuffer(&bufferInfo, &alloc_info, m_buffer, alloc_name.c_str());
m_debug_name = std::move(alloc_name);
#else
m_allocation = RenderCore::Get().GetAllocator().CreateBuffer(&bufferInfo, &alloc_info, m_buffer, nullptr);
#endif
@@ -85,7 +85,6 @@ namespace mlx
kvfEndCommandBuffer(cmd);
VkFence fence = kvfCreateFence(RenderCore::Get().GetDevice());
kvfSubmitSingleTimeCommandBuffer(RenderCore::Get().GetDevice(), cmd, KVF_GRAPHICS_QUEUE, fence);
kvfWaitForFence(RenderCore::Get().GetDevice(), fence);
kvfDestroyFence(RenderCore::Get().GetDevice(), fence);
return true;
}

101
runtime/Sources/Renderer/Descriptor.cpp
View File

@@ -5,9 +5,12 @@
#include <Renderer/Buffer.h>
#include <Renderer/Descriptor.h>
#include <Renderer/RenderCore.h>
#include <Maths/Constants.h>
namespace mlx
{
constexpr std::size_t MAX_SETS_PER_POOL = MAX_FRAMES_IN_FLIGHT * 1024;
void TransitionImageToCorrectLayout(Image& image, VkCommandBuffer cmd)
{
MLX_PROFILE_FUNCTION();
@@ -19,8 +22,89 @@ namespace mlx
Error("Vulkan : cannot transition descriptor image layout, unkown image type");
}
DescriptorSet::DescriptorSet(const ShaderSetLayout& layout, VkDescriptorSetLayout vklayout, ShaderType shader_type)
: m_set_layout(vklayout)
void DescriptorPool::Init() noexcept
{
VkDescriptorPoolSize pool_sizes[] = {
{ VK_DESCRIPTOR_TYPE_SAMPLER, MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, MAX_SETS_PER_POOL }
};
VkDescriptorPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.poolSizeCount = sizeof(pool_sizes) / sizeof(pool_sizes[0]);
poolInfo.pPoolSizes = pool_sizes;
poolInfo.maxSets = MAX_SETS_PER_POOL;
poolInfo.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
kvfCheckVk(RenderCore::Get().vkCreateDescriptorPool(RenderCore::Get().GetDevice(), &poolInfo, nullptr, &m_pools[i]));
m_allocation_count = 0;
}
void DescriptorPool::Destroy() noexcept
{
for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
{
if(m_pools[i] == VK_NULL_HANDLE)
continue;
RenderCore::Get().vkDestroyDescriptorPool(RenderCore::Get().GetDevice(), m_pools[i], nullptr);
m_pools[i] = VK_NULL_HANDLE;
}
m_allocation_count = 0;
}
VkDescriptorSet DescriptorPool::AllocateDescriptorSet(std::uint32_t frame_index, VkDescriptorSetLayout layout)
{
VkDescriptorSet set;
VkDescriptorSetAllocateInfo alloc_info = {};
alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
alloc_info.descriptorPool = m_pools[frame_index];
alloc_info.descriptorSetCount = 1;
alloc_info.pSetLayouts = &layout;
kvfCheckVk(RenderCore::Get().vkAllocateDescriptorSets(RenderCore::Get().GetDevice(), &alloc_info, &set));
m_allocation_count++;
return set;
}
void DescriptorPool::ResetPoolFromFrameIndex(std::size_t frame_index)
{
Assert(frame_index < MAX_FRAMES_IN_FLIGHT, "invalid frame index");
RenderCore::Get().vkResetDescriptorPool(RenderCore::Get().GetDevice(), m_pools[frame_index], 0);
}
void DescriptorPoolManager::ResetPoolsFromFrameIndex(std::size_t frame_index)
{
for(auto& pool : m_pools)
pool.ResetPoolFromFrameIndex(frame_index);
}
DescriptorPool& DescriptorPoolManager::GetAvailablePool()
{
for(auto& pool : m_pools)
{
if(pool.GetNumberOfSetsAllocated() < MAX_SETS_PER_POOL)
return pool;
}
m_pools.emplace_front().Init();
return m_pools.front();
}
void DescriptorPoolManager::Destroy()
{
for(auto& pool : m_pools)
pool.Destroy();
}
DescriptorSet::DescriptorSet(DescriptorPoolManager& pools_manager, const ShaderSetLayout& layout, VkDescriptorSetLayout vklayout, ShaderType shader_type)
: m_set_layout(vklayout), p_pools_manager(&pools_manager)
{
MLX_PROFILE_FUNCTION();
for(auto& [binding, type] : layout.binds)
@@ -31,15 +115,15 @@ namespace mlx
m_descriptors.back().binding = binding;
}
for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
m_set[i] = kvfAllocateDescriptorSet(RenderCore::Get().GetDevice(), vklayout);
m_set[i] = p_pools_manager->GetAvailablePool().AllocateDescriptorSet(i, vklayout);
}
DescriptorSet::DescriptorSet(VkDescriptorSetLayout layout, const std::vector<Descriptor>& descriptors)
: m_descriptors(descriptors), m_set_layout(layout)
DescriptorSet::DescriptorSet(DescriptorPoolManager& pools_manager, VkDescriptorSetLayout layout, const std::vector<Descriptor>& descriptors)
: m_descriptors(descriptors), m_set_layout(layout), p_pools_manager(&pools_manager)
{
MLX_PROFILE_FUNCTION();
for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
m_set[i] = kvfAllocateDescriptorSet(RenderCore::Get().GetDevice(), layout);
m_set[i] = p_pools_manager->GetAvailablePool().AllocateDescriptorSet(i, layout);
}
void DescriptorSet::SetImage(std::size_t i, std::uint32_t binding, class Image& image)
@@ -146,10 +230,9 @@ namespace mlx
RenderCore::Get().vkUpdateDescriptorSets(RenderCore::Get().GetDevice(), writes.size(), writes.data(), 0, nullptr);
}
void DescriptorSet::Reallocate() noexcept
void DescriptorSet::Reallocate(std::size_t frame_index) noexcept
{
MLX_PROFILE_FUNCTION();
for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
m_set[i] = kvfAllocateDescriptorSet(RenderCore::Get().GetDevice(), m_set_layout);
m_set[frame_index] = p_pools_manager->GetAvailablePool().AllocateDescriptorSet(frame_index, m_set_layout);
}
}

7
runtime/Sources/Renderer/Image.cpp
View File

@@ -100,22 +100,21 @@ namespace mlx
subresource_range.levelCount = 1;
subresource_range.baseArrayLayer = 0;
VkImageLayout old_layout = m_layout;
TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, cmd);
if(m_type == ImageType::Color)
{
VkImageLayout old_layout = m_layout;
TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, cmd);
subresource_range.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
VkClearColorValue clear_color = VkClearColorValue({ { color.x, color.y, color.z, color.w } });
RenderCore::Get().vkCmdClearColorImage(cmd, m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &subresource_range);
TransitionLayout(old_layout, cmd);
}
else if(m_type == ImageType::Depth)
{
VkClearDepthStencilValue clear_depth_stencil = { 1.0f, 1 };
subresource_range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, cmd);
RenderCore::Get().vkCmdClearDepthStencilImage(cmd, m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_depth_stencil, 1, &subresource_range);
}
TransitionLayout(old_layout, cmd);
}
void Image::DestroySampler() noexcept

36
runtime/Sources/Renderer/Pipelines/Graphics.cpp
View File

@@ -1,3 +1,4 @@
#include "vulkan/vulkan_core.h"
#include <PreCompiled.h>
#include <Renderer/Pipelines/Graphics.h>
#include <Renderer/RenderCore.h>
@@ -7,7 +8,7 @@
namespace mlx
{
void GraphicPipeline::Init(const GraphicPipelineDescriptor& descriptor)
void GraphicPipeline::Init(const GraphicPipelineDescriptor& descriptor, std::string_view debug_name)
{
MLX_PROFILE_FUNCTION();
if(!descriptor.vertex_shader || !descriptor.fragment_shader)
@@ -19,6 +20,10 @@ namespace mlx
p_renderer = descriptor.renderer;
p_depth = descriptor.depth;
#ifdef DEBUG
m_debug_name = debug_name;
#endif
std::vector<VkPushConstantRange> push_constants;
std::vector<VkDescriptorSetLayout> set_layouts;
push_constants.insert(push_constants.end(), p_vertex_shader->GetPipelineLayout().push_constants.begin(), p_vertex_shader->GetPipelineLayout().push_constants.end());
@@ -31,7 +36,7 @@ namespace mlx
CreateFramebuffers(m_attachments, descriptor.clear_color_attachments);
VkPhysicalDeviceFeatures features{};
mlx::RenderCore::Get().vkGetPhysicalDeviceFeatures(RenderCore::Get().GetPhysicalDevice(), &features);
RenderCore::Get().vkGetPhysicalDeviceFeatures(RenderCore::Get().GetPhysicalDevice(), &features);
KvfGraphicsPipelineBuilder* builder = kvfCreateGPipelineBuilder();
kvfGPipelineBuilderAddShaderStage(builder, p_vertex_shader->GetShaderStage(), p_vertex_shader->GetShaderModule(), "main");
@@ -59,6 +64,33 @@ namespace mlx
m_pipeline = kvfCreateGraphicsPipeline(RenderCore::Get().GetDevice(), m_pipeline_layout, builder, m_renderpass);
DebugLog("Vulkan : graphics pipeline created");
kvfDestroyGPipelineBuilder(builder);
#ifdef MLX_HAS_DEBUG_UTILS_FUNCTIONS
VkDebugUtilsObjectNameInfoEXT name_info{};
name_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
name_info.objectType = VK_OBJECT_TYPE_PIPELINE;
name_info.objectHandle = reinterpret_cast<std::uint64_t>(m_pipeline);
name_info.pObjectName = m_debug_name.c_str();
RenderCore::Get().vkSetDebugUtilsObjectNameEXT(RenderCore::Get().GetDevice(), &name_info);
name_info.objectType = VK_OBJECT_TYPE_RENDER_PASS;
name_info.objectHandle = reinterpret_cast<std::uint64_t>(m_renderpass);
RenderCore::Get().vkSetDebugUtilsObjectNameEXT(RenderCore::Get().GetDevice(), &name_info);
name_info.objectType = VK_OBJECT_TYPE_SHADER_MODULE;
name_info.objectHandle = reinterpret_cast<std::uint64_t>(p_vertex_shader->GetShaderModule());
RenderCore::Get().vkSetDebugUtilsObjectNameEXT(RenderCore::Get().GetDevice(), &name_info);
name_info.objectHandle = reinterpret_cast<std::uint64_t>(p_fragment_shader->GetShaderModule());
RenderCore::Get().vkSetDebugUtilsObjectNameEXT(RenderCore::Get().GetDevice(), &name_info);
name_info.objectType = VK_OBJECT_TYPE_FRAMEBUFFER;
for(VkFramebuffer fb : m_framebuffers)
{
name_info.objectHandle = reinterpret_cast<std::uint64_t>(fb);
RenderCore::Get().vkSetDebugUtilsObjectNameEXT(RenderCore::Get().GetDevice(), &name_info);
}
#endif
}
bool GraphicPipeline::BindPipeline(VkCommandBuffer command_buffer, std::size_t framebuffer_index, std::array<float, 4> clear) noexcept

33
runtime/Sources/Renderer/RenderPasses/2DPass.cpp
View File

@@ -14,7 +14,7 @@ namespace mlx
Vec4f position;
};
void Render2DPass::Init()
void Render2DPass::Init(Renderer& renderer)
{
MLX_PROFILE_FUNCTION();
ShaderLayout vertex_shader_layout(
@@ -44,25 +44,24 @@ namespace mlx
};
p_fragment_shader = std::make_shared<Shader>(fragment_shader_code, ShaderType::Fragment, std::move(fragment_shader_layout));
func::function<void(const EventBase&)> functor = [this](const EventBase& event)
func::function<void(const EventBase&)> functor = [this, &renderer](const EventBase& event)
{
if(event.What() == Event::ResizeEventCode)
m_pipeline.Destroy();
if(event.What() == Event::DescriptorPoolResetEventCode)
{
p_texture_set->Reallocate();
p_viewer_data_set->Reallocate();
for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
{
p_viewer_data_set->SetUniformBuffer(i, 0, p_viewer_data_buffer->Get(i));
p_viewer_data_set->Update(i);
}
std::uint32_t frame_index = renderer.GetCurrentFrameIndex();
p_texture_set->Reallocate(frame_index);
p_viewer_data_set->Reallocate(frame_index);
p_viewer_data_set->SetUniformBuffer(frame_index, 0, p_viewer_data_buffer->Get(frame_index));
p_viewer_data_set->Update(frame_index);
}
};
EventBus::RegisterListener({ functor, "__MlxRender2DPass" });
p_viewer_data_set = std::make_shared<DescriptorSet>(p_vertex_shader->GetShaderLayout().set_layouts[0].second, p_vertex_shader->GetPipelineLayout().set_layouts[0], ShaderType::Vertex);
p_texture_set = std::make_shared<DescriptorSet>(p_fragment_shader->GetShaderLayout().set_layouts[0].second, p_fragment_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);
p_viewer_data_set = std::make_shared<DescriptorSet>(renderer.GetDescriptorPoolManager(), p_vertex_shader->GetShaderLayout().set_layouts[0].second, p_vertex_shader->GetPipelineLayout().set_layouts[0], ShaderType::Vertex);
p_texture_set = std::make_shared<DescriptorSet>(renderer.GetDescriptorPoolManager(), p_fragment_shader->GetShaderLayout().set_layouts[0].second, p_fragment_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);
p_viewer_data_buffer = std::make_shared<UniformBuffer>();
p_viewer_data_buffer->Init(sizeof(ViewerData), "mlx_2d_pass_viewer_data");
@@ -84,13 +83,17 @@ namespace mlx
pipeline_descriptor.color_attachments = { &render_target };
pipeline_descriptor.depth = &scene.GetDepth();
pipeline_descriptor.clear_color_attachments = false;
m_pipeline.Init(pipeline_descriptor);
#ifdef DEBUG
m_pipeline.Init(pipeline_descriptor, "mlx_2D_pass");
#else
m_pipeline.Init(pipeline_descriptor, {});
#endif
}
std::uint32_t frame_index = renderer.GetCurrentFrameIndex();
ViewerData viewer_data;
viewer_data.projection_matrix = Mat4f::Ortho(0.0f, render_target.GetWidth(), render_target.GetHeight(), 0.0f);
viewer_data.projection_matrix = Mat4f::Ortho(0.0f, render_target.GetWidth(), 0.0f, render_target.GetHeight(), -1.0f, 100'000.0f);
static CPUBuffer buffer(sizeof(ViewerData));
std::memcpy(buffer.GetData(), &viewer_data, buffer.GetSize());
p_viewer_data_buffer->SetData(buffer, frame_index);
@@ -108,8 +111,8 @@ namespace mlx
sprite->GetTexture()->Update(cmd);
sprite->Bind(frame_index, cmd);
std::array<VkDescriptorSet, 2> sets = { p_viewer_data_set->GetSet(frame_index), sprite->GetSet(frame_index) };
mlx::RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr);
mlx::RenderCore::Get().vkCmdPushConstants(cmd, m_pipeline.GetPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(SpriteData), &sprite_data);
RenderCore::Get().vkCmdBindDescriptorSets(cmd, m_pipeline.GetPipelineBindPoint(), m_pipeline.GetPipelineLayout(), 0, sets.size(), sets.data(), 0, nullptr);
RenderCore::Get().vkCmdPushConstants(cmd, m_pipeline.GetPipelineLayout(), VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(SpriteData), &sprite_data);
sprite->GetMesh()->Draw(cmd, renderer.GetDrawCallsCounterRef(), renderer.GetPolygonDrawnCounterRef());
}
m_pipeline.EndPipeline(cmd);

14
runtime/Sources/Renderer/RenderPasses/FinalPass.cpp
View File

@@ -7,7 +7,7 @@
namespace mlx
{
void FinalPass::Init()
void FinalPass::Init(Renderer& renderer)
{
MLX_PROFILE_FUNCTION();
ShaderLayout vertex_shader_layout(
@@ -31,16 +31,16 @@ namespace mlx
};
p_fragment_shader = std::make_shared<Shader>(fragment_shader_code, ShaderType::Fragment, std::move(fragment_shader_layout));
func::function<void(const EventBase&)> functor = [this](const EventBase& event)
func::function<void(const EventBase&)> functor = [this, &renderer](const EventBase& event)
{
if(event.What() == Event::ResizeEventCode)
m_pipeline.Destroy();
if(event.What() == Event::DescriptorPoolResetEventCode)
p_set->Reallocate();
p_set->Reallocate(renderer.GetCurrentFrameIndex());
};
EventBus::RegisterListener({ functor, "__MlxFinalPass" });
p_set = std::make_shared<DescriptorSet>(p_fragment_shader->GetShaderLayout().set_layouts[0].second, p_fragment_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);
p_set = std::make_shared<DescriptorSet>(renderer.GetDescriptorPoolManager(), p_fragment_shader->GetShaderLayout().set_layouts[0].second, p_fragment_shader->GetPipelineLayout().set_layouts[0], ShaderType::Fragment);
}
void FinalPass::Pass([[maybe_unused]] Scene& scene, Renderer& renderer, Texture& render_target)
@@ -53,7 +53,11 @@ namespace mlx
pipeline_descriptor.fragment_shader = p_fragment_shader;
pipeline_descriptor.renderer = &renderer;
pipeline_descriptor.no_vertex_inputs = true;
m_pipeline.Init(pipeline_descriptor);
#ifdef DEBUG
m_pipeline.Init(pipeline_descriptor, "mlx_final_pass");
#else
m_pipeline.Init(pipeline_descriptor, {});
#endif
}
VkCommandBuffer cmd = renderer.GetActiveCommandBuffer();

54
runtime/Sources/Renderer/RenderPasses/Passes.cpp
View File

@@ -5,39 +5,37 @@
namespace mlx
{
void RenderPasses::Init()
void RenderPasses::Init(Renderer& renderer)
{
m_2Dpass.Init();
m_final.Init();
m_2Dpass.Init(renderer);
m_final.Init(renderer);
func::function<void(const EventBase&)> functor = [this, renderer](const EventBase& event)
{
if(event.What() == Event::ResizeEventCode)
{
m_main_render_texture.Destroy();
auto extent = kvfGetSwapchainImagesSize(renderer.GetSwapchain());
#ifdef DEBUG
m_main_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_SRGB, false, "mlx_renderpasses_target");
#else
m_main_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_SRGB, false, {});
#endif
m_main_render_texture.TransitionLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
}
};
EventBus::RegisterListener({ functor, "__MlxRenderPasses" });
auto extent = kvfGetSwapchainImagesSize(renderer.GetSwapchain());
#ifdef DEBUG
m_main_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_SRGB, false, "mlx_renderpasses_target");
#else
m_main_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_SRGB, false, {});
#endif
m_main_render_texture.TransitionLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
}
void RenderPasses::Pass(Scene& scene, Renderer& renderer)
{
if(!m_main_render_texture.IsInit())
{
func::function<void(const EventBase&)> functor = [this, renderer](const EventBase& event)
{
if(event.What() == Event::ResizeEventCode)
{
m_main_render_texture.Destroy();
auto extent = kvfGetSwapchainImagesSize(renderer.GetSwapchain());
#ifdef DEBUG
m_main_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_SRGB, false, "mlx_renderpasses_target");
#else
m_main_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_SRGB, false, {});
#endif
}
};
EventBus::RegisterListener({ functor, "__MlxRenderPasses" });
auto extent = kvfGetSwapchainImagesSize(renderer.GetSwapchain());
#ifdef DEBUG
m_main_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_SRGB, false, "mlx_renderpasses_target");
#else
m_main_render_texture.Init({}, extent.width, extent.height, VK_FORMAT_R8G8B8A8_SRGB, false, {});
#endif
}
m_main_render_texture.Clear(renderer.GetActiveCommandBuffer(), Vec4f{ 0.0f, 0.0f, 0.0f, 1.0f });
scene.GetDepth().Clear(renderer.GetActiveCommandBuffer(), {});

10
runtime/Sources/Renderer/Renderer.cpp
View File

@@ -59,6 +59,13 @@ namespace mlx
{
MLX_PROFILE_FUNCTION();
kvfWaitForFence(RenderCore::Get().GetDevice(), m_cmd_fences[m_current_frame_index]);
static bool first_run = true;
if(!first_run)
{
m_descriptor_pool_manager.ResetPoolsFromFrameIndex(m_current_frame_index);
EventBus::SendBroadcast(Internal::DescriptorPoolResetEventBroadcast{});
}
first_run = false;
VkResult result = RenderCore::Get().vkAcquireNextImageKHR(RenderCore::Get().GetDevice(), m_swapchain, UINT64_MAX, m_image_available_semaphores[m_current_frame_index], VK_NULL_HANDLE, &m_swapchain_image_index);
if(result == VK_ERROR_OUT_OF_DATE_KHR)
{
@@ -92,8 +99,6 @@ namespace mlx
EventBus::SendBroadcast(Internal::ResizeEventBroadcast{});
}
m_current_frame_index = (m_current_frame_index + 1) % MAX_FRAMES_IN_FLIGHT;
kvfResetDeviceDescriptorPools(RenderCore::Get().GetDevice());
EventBus::SendBroadcast(Internal::DescriptorPoolResetEventBroadcast{});
}
void Renderer::CreateSwapchain()
@@ -145,6 +150,7 @@ namespace mlx
DebugLog("Vulkan : fence destroyed");
}
m_descriptor_pool_manager.Destroy();
DestroySwapchain();
RenderCore::Get().vkDestroySurfaceKHR(RenderCore::Get().GetInstance(), m_surface, nullptr);
DebugLog("Vulkan : surface destroyed");

4
runtime/Sources/Renderer/SceneRenderer.cpp
View File

@@ -6,10 +6,10 @@
namespace mlx
{
void SceneRenderer::Init()
void SceneRenderer::Init(Renderer& renderer)
{
MLX_PROFILE_FUNCTION();
m_passes.Init();
m_passes.Init(renderer);
}
void SceneRenderer::Render(Scene& scene, Renderer& renderer)