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

working on code refactor

Browse Source
This commit is contained in:
kbz_8
2024-04-23 20:59:50 +02:00
parent 215a0dc2c3
commit ace4c98945
53 changed files with 1378 additions and 1403 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
runtime/Sources/Renderer/Descriptors/DescriptorPool.cpp git.filemode.normal_file
View File

@@ -0,0 +1,69 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* DescriptorPool.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:34:23 by maldavid #+# #+# */
/* Updated: 2024/04/23 19:39:39 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <PreCompiled.h>
#include <Renderer/Descriptors/DescriptorPool.h>
#include <Renderer/Descriptors/DescriptorSet.h>
#include <Renderer/Core/RenderCore.h>
namespace mlx
{
void DescriptorPool::Init(std::vector<VkDescriptorPoolSize> sizes)
{
VkDescriptorPoolCreateInfo pool_info{};
pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
pool_info.poolSizeCount = sizes.size();
pool_info.pPoolSizes = sizes.data();
pool_info.maxSets = MAX_SETS_PER_POOL;
pool_info.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
VkResult res = vkCreateDescriptorPool(RenderCore::Get().GetDevice().Get(), &pool_info, nullptr, &m_pool);
if(res != VK_SUCCESS)
FatalError("Vulkan : failed to create descriptor pool, %", VerbaliseVkResult(res));
DebugLog("Vulkan : created new descriptor pool");
}
VkDescriptorSet DescriptorPool::AllocateDescriptorSet(class DescriptorSetLayout& layout)
{
VkDescriptorSet set;
VkDescriptorSetAllocateInfo alloc_info{};
alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
alloc_info.descriptorPool = m_pool;
alloc_info.descriptorSetCount = 1;
alloc_info.pSetLayouts = layouts.Get();
VkResult res = vkAllocateDescriptorSets(RenderCore::Get().GetDevice().Get(), &alloc_info, &set);
if(res != VK_SUCCESS)
FatalError("Vulkan : failed to allocate descriptor set, %", VerbaliseVkResult(res));
m_allocated_sets++;
DebugLog("Vulkan : created new descriptor set");
return set;
}
void DescriptorPool::FreeDescriptor(VkDescriptorSet set)
{
if(!IsInit())
return;
vkFreeDescriptorSets(RenderCore::Get().GetDevice().Get(), m_pool, 1, set);
m_allocated_sets--; // if this goes underflow I quit
}
void DescriptorPool::Destroy() noexcept
{
if(m_pool != VK_NULL_HANDLE)
vkDestroyDescriptorPool(RenderCore::Get().GetDevice().Get(), m_pool, nullptr);
m_pool = VK_NULL_HANDLE;
DebugLog("Vulkan : destroyed a descriptor pool");
}
}

30
runtime/Sources/Renderer/Descriptors/descriptor_pool_manager.cpp → runtime/Sources/Renderer/Descriptors/DescriptorPoolManager.cpp
View File

@@ -1,41 +1,41 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* descriptor_pool_manager.cpp :+: :+: :+: */
/* DescriptorPoolManager.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/20 06:51:47 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:02:29 by maldavid ### ########.fr */
/* Updated: 2024/04/23 19:41:38 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <pre_compiled.h>
#include <PreCompiled.h>
#include <renderer/core/render_core.h>
#include <renderer/descriptors/descriptor_pool_manager.h>
#include <Renderer/Core/RenderCore.h>
#include <Renderer/Descriptors/DescriptorPoolManager.h>
namespace mlx
{
DescriptorPool& DescriptorPoolManager::getAvailablePool()
DescriptorPool& DescriptorPoolManager::GetAvailablePool()
{
for(auto& pool : _pools)
for(auto& pool : m_pools)
{
if(pool.getNumberOfSetsAllocated() < MAX_SETS_PER_POOL)
if(pool.GetNumberOfSetsAllocated() < MAX_SETS_PER_POOL)
return pool;
}
VkDescriptorPoolSize pool_sizes[] = {
std::vector<VkDescriptorPoolSize> pool_sizes = {
{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, (MAX_FRAMES_IN_FLIGHT * NUMBER_OF_UNIFORM_BUFFERS) },
{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, MAX_SETS_PER_POOL - (MAX_FRAMES_IN_FLIGHT * NUMBER_OF_UNIFORM_BUFFERS) }
};
_pools.emplace_front().init((sizeof(pool_sizes) / sizeof(VkDescriptorPoolSize)), pool_sizes);
return _pools.front();
m_pools.emplace_front().Init(std::move(pool_sizes));
return m_pools.front();
}
void DescriptorPoolManager::destroyAllPools()
void DescriptorPoolManager::DestroyAllPools()
{
for(auto& pool : _pools)
pool.destroy();
_pools.clear();
for(auto& pool : m_pools)
pool.Destroy();
m_pools.clear();
}
}

111
runtime/Sources/Renderer/Descriptors/DescriptorSet.cpp git.filemode.normal_file
View File

@@ -0,0 +1,111 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* DescriptorSet.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:40:44 by maldavid #+# #+# */
/* Updated: 2024/04/23 19:50:06 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <PreCompiled.h>
#include <Renderer/Descriptors/DescriptorSet.h>
#include <Renderer/Core/RenderCore.h>
#include <Renderer/Descriptors/DescriptorPool.h>
#include <Renderer/Buffers/UniformBuffer.h>
#include <Renderer/Renderer.h>
#include <Renderer/Images/Image.h>
namespace mlx
{
void DescriptorSet::Init(NonOwningPtr<Renderer> renderer, NonOwningPtr<DescriptorPool> pool, DescriptorSetLayout layout)
{
MLX_PROFILE_FUNCTION();
m_renderer = renderer;
m_layout = layout;
m_pool = pool;
for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
m_desc_set[i] = pool->AllocateDescriptorSet(layout);
}
void DescriptorSet::WriteDescriptor(int binding, NonOwningPtr<UniformBuffer> ubo) const noexcept
{
MLX_PROFILE_FUNCTION();
auto device = RenderCore::Get().GetDevice().Get();
for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
{
VkDescriptorBufferInfo buffer_info{};
buffer_info.buffer = ubo->Get(i);
buffer_info.offset = ubo->GetOffset(i);
buffer_info.range = ubo->GetSize(i);
VkWriteDescriptorSet descriptor_write{};
descriptor_write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptor_write.dstSet = m_desc_set[i];
descriptor_write.dstBinding = binding;
descriptor_write.dstArrayElement = 0;
descriptor_write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
descriptor_write.descriptorCount = 1;
descriptor_write.pBufferInfo = &buffer_info;
vkUpdateDescriptorSets(device, 1, &descriptor_write, 0, nullptr);
}
}
void DescriptorSet::WriteDescriptor(int binding, const Image& image) const noexcept
{
MLX_PROFILE_FUNCTION();
auto device = RenderCore::Get().GetDevice().Get();
VkDescriptorImageInfo image_info{};
image_info.imageLayout = image.GetLayout();
image_info.imageView = image.GetImageView();
image_info.sampler = image.GetSampler();
VkWriteDescriptorSet descriptor_write{};
descriptor_write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptor_write.dstSet = m_desc_set[m_renderer->GetActiveImageIndex()];
descriptor_write.dstBinding = binding;
descriptor_write.dstArrayElement = 0;
descriptor_write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
descriptor_write.descriptorCount = 1;
descriptor_write.pImageInfo = &image_info;
vkUpdateDescriptorSets(device, 1, &descriptor_write, 0, nullptr);
}
DescriptorSet DescriptorSet::Duplicate()
{
MLX_PROFILE_FUNCTION();
DescriptorSet set;
set.Init(m_renderer, &RenderCore::Get().GetDescriptorPool(), m_layout);
return set;
}
VkDescriptorSet& DescriptorSet::operator()() noexcept
{
return m_desc_set[m_renderer->GetActiveImageIndex()];
}
VkDescriptorSet& DescriptorSet::Get() noexcept
{
return m_desc_set[m_renderer->GetActiveImageIndex()];
}
void DescriptorSet::Destroy() noexcept
{
MLX_PROFILE_FUNCTION();
if(m_pool != nullptr && RenderCore::Get().IsInit()) // checks if the render core is still init (it should always be init but just in case)
m_pool->FreeDescriptor(*this);
for(auto& set : m_desc_set)
{
if(set != VK_NULL_HANDLE)
set = VK_NULL_HANDLE;
}
}
}

32
runtime/Sources/Renderer/Descriptors/vk_descriptor_set_layout.cpp → runtime/Sources/Renderer/Descriptors/DescriptorSetLayout.cpp
View File

@@ -1,23 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_descriptor_set_layout.cpp :+: :+: :+: */
/* DescriptorSetLayout.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:37:28 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:02:47 by maldavid ### ########.fr */
/* Updated: 2024/04/23 19:52:41 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <pre_compiled.h>
#include <PreCompiled.h>
#include "vk_descriptor_set_layout.h"
#include <renderer/core/render_core.h>
#include <Renderer/Descriptors/DescriptorSetLayout.h>
#include <Renderer/Core/Rendercore.h>
namespace mlx
{
void DescriptorSetLayout::init(std::vector<std::pair<int, VkDescriptorType>> binds, VkShaderStageFlagBits stage)
void DescriptorSetLayout::Init(std::vector<std::pair<int, VkDescriptorType>> binds, VkShaderStageFlagBits stage)
{
std::vector<VkDescriptorSetLayoutBinding> bindings(binds.size());
for(std::size_t i = 0; i < binds.size(); i++)
@@ -29,21 +29,21 @@ namespace mlx
bindings[i].stageFlags = stage;
}
_bindings = std::move(binds);
m_bindings = std::move(binds);
VkDescriptorSetLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutInfo.bindingCount = _bindings.size();
layoutInfo.pBindings = bindings.data();
VkDescriptorSetLayoutCreateInfo layout_info{};
layout_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layout_info.bindingCount = m_bindings.size();
layout_info.pBindings = m_bindings.data();
VkResult res = vkCreateDescriptorSetLayout(Render_Core::get().getDevice().get(), &layoutInfo, nullptr, &_layout);
VkResult res = vkCreateDescriptorSetLayout(RenderCore::Get().GetDevice().Get(), &layout_info, nullptr, &m_layout);
if(res != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : failed to create descriptor set layout, %s", RCore::verbaliseResultVk(res));
FatalError("Vulkan : failed to create descriptor set layout, %", VerbaliseVkResult(res));
}
void DescriptorSetLayout::destroy() noexcept
void DescriptorSetLayout::Destroy() noexcept
{
vkDestroyDescriptorSetLayout(Render_Core::get().getDevice().get(), _layout, nullptr);
_layout = VK_NULL_HANDLE;
vkDestroyDescriptorSetLayout(RenderCore::Get().GetDevice().Get(), m_layout, nullptr);
m_layout = VK_NULL_HANDLE;
}
}

57
runtime/Sources/Renderer/Descriptors/vk_descriptor_pool.cpp
View File

@@ -1,57 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_descriptor_pool.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:34:23 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:02:37 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <pre_compiled.h>
#include "vk_descriptor_pool.h"
#include <renderer/descriptors/vk_descriptor_set.h>
#include <renderer/core/render_core.h>
namespace mlx
{
void DescriptorPool::init(std::size_t n, VkDescriptorPoolSize* size)
{
VkDescriptorPoolCreateInfo poolInfo{};
poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
poolInfo.poolSizeCount = n;
poolInfo.pPoolSizes = size;
poolInfo.maxSets = MAX_SETS_PER_POOL;
poolInfo.flags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;
VkResult res = vkCreateDescriptorPool(Render_Core::get().getDevice().get(), &poolInfo, nullptr, &_pool);
if(res != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : failed to create descriptor pool, %s", RCore::verbaliseResultVk(res));
_allocated_sets++;
#ifdef DEBUG
core::error::report(e_kind::message, "Vulkan : created new descriptor pool");
#endif
}
void DescriptorPool::freeDescriptor(const DescriptorSet& set)
{
if(!isInit())
return;
const auto& sets = set.getAllFramesDescriptorSets();
vkFreeDescriptorSets(Render_Core::get().getDevice().get(), _pool, sets.size(), sets.data());
_allocated_sets--; // if this goes in underflow I quit
}
void DescriptorPool::destroy() noexcept
{
if(_pool != VK_NULL_HANDLE)
vkDestroyDescriptorPool(Render_Core::get().getDevice().get(), _pool, nullptr);
_pool = VK_NULL_HANDLE;
#ifdef DEBUG
core::error::report(e_kind::message, "Vulkan : destroyed a descriptor pool");
#endif
}
}

131
runtime/Sources/Renderer/Descriptors/vk_descriptor_set.cpp
View File

@@ -1,131 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_descriptor_set.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:40:44 by maldavid #+# #+# */
/* Updated: 2024/03/25 19:02:43 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include <pre_compiled.h>
#include "vk_descriptor_set.h"
#include "renderer/core/render_core.h"
#include "vk_descriptor_pool.h"
#include "vk_descriptor_set_layout.h"
#include <renderer/buffers/vk_ubo.h>
#include <renderer/renderer.h>
#include <renderer/images/vk_image.h>
#include <core/profiler.h>
namespace mlx
{
void DescriptorSet::init(Renderer* renderer, DescriptorPool* pool, DescriptorSetLayout* layout)
{
MLX_PROFILE_FUNCTION();
_renderer = renderer;
_layout = layout;
_pool = pool;
auto device = Render_Core::get().getDevice().get();
std::array<VkDescriptorSetLayout, MAX_FRAMES_IN_FLIGHT> layouts;
layouts.fill(layout->get());
VkDescriptorSetAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
allocInfo.descriptorPool = _pool->get();
allocInfo.descriptorSetCount = static_cast<std::uint32_t>(MAX_FRAMES_IN_FLIGHT);
allocInfo.pSetLayouts = layouts.data();
VkResult res = vkAllocateDescriptorSets(device, &allocInfo, _desc_set.data());
if(res != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : failed to allocate descriptor set, %s", RCore::verbaliseResultVk(res));
#ifdef DEBUG
core::error::report(e_kind::message, "Vulkan : created new descriptor set");
#endif
}
void DescriptorSet::writeDescriptor(int binding, UBO* ubo) const noexcept
{
MLX_PROFILE_FUNCTION();
auto device = Render_Core::get().getDevice().get();
for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
{
VkDescriptorBufferInfo bufferInfo{};
bufferInfo.buffer = ubo->get(i);
bufferInfo.offset = ubo->getOffset(i);
bufferInfo.range = ubo->getSize(i);
VkWriteDescriptorSet descriptorWrite{};
descriptorWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptorWrite.dstSet = _desc_set[i];
descriptorWrite.dstBinding = binding;
descriptorWrite.dstArrayElement = 0;
descriptorWrite.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
descriptorWrite.descriptorCount = 1;
descriptorWrite.pBufferInfo = &bufferInfo;
vkUpdateDescriptorSets(device, 1, &descriptorWrite, 0, nullptr);
}
}
void DescriptorSet::writeDescriptor(int binding, const Image& image) const noexcept
{
MLX_PROFILE_FUNCTION();
auto device = Render_Core::get().getDevice().get();
VkDescriptorImageInfo imageInfo{};
imageInfo.imageLayout = image.getLayout();
imageInfo.imageView = image.getImageView();
imageInfo.sampler = image.getSampler();
VkWriteDescriptorSet descriptorWrite{};
descriptorWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptorWrite.dstSet = _desc_set[_renderer->getActiveImageIndex()];
descriptorWrite.dstBinding = binding;
descriptorWrite.dstArrayElement = 0;
descriptorWrite.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
descriptorWrite.descriptorCount = 1;
descriptorWrite.pImageInfo = &imageInfo;
vkUpdateDescriptorSets(device, 1, &descriptorWrite, 0, nullptr);
}
DescriptorSet DescriptorSet::duplicate()
{
MLX_PROFILE_FUNCTION();
DescriptorSet set;
set.init(_renderer, &Render_Core::get().getDescriptorPool(), _layout);
return set;
}
VkDescriptorSet& DescriptorSet::operator()() noexcept
{
return _desc_set[_renderer->getActiveImageIndex()];
}
VkDescriptorSet& DescriptorSet::get() noexcept
{
return _desc_set[_renderer->getActiveImageIndex()];
}
void DescriptorSet::destroy() noexcept
{
MLX_PROFILE_FUNCTION();
if(_pool != nullptr && Render_Core::get().isInit()) // checks if the render core is still init (it should always be init but just in case)
_pool->freeDescriptor(*this);
for(auto& set : _desc_set)
{
if(set != VK_NULL_HANDLE)
set = VK_NULL_HANDLE;
}
#ifdef DEBUG
core::error::report(e_kind::message, "Vulkan : destroyed descriptor set");
#endif
}
}