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

fixing put pixel, adding scene change checker

Browse Source
This commit is contained in:
Kbz-8
2024-10-21 01:48:01 +02:00
parent 59455495b6
commit c7484b771f
28 changed files with 302 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -24,6 +24,7 @@ namespace mlx
void DescriptorPool::Init() noexcept
{
MLX_PROFILE_FUNCTION();
VkDescriptorPoolSize pool_sizes[] = {
{ VK_DESCRIPTOR_TYPE_SAMPLER, MAX_SETS_PER_POOL },
{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, MAX_SETS_PER_POOL },
@@ -38,99 +39,143 @@ namespace mlx
{ 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]));
VkDescriptorPoolCreateInfo pool_info{};
pool_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
pool_info.poolSizeCount = sizeof(pool_sizes) / sizeof(pool_sizes[0]);
pool_info.pPoolSizes = pool_sizes;
pool_info.maxSets = MAX_SETS_PER_POOL;
pool_info.flags = 0;
kvfCheckVk(RenderCore::Get().vkCreateDescriptorPool(RenderCore::Get().GetDevice(), &pool_info, nullptr, &m_pool));
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;
}
MLX_PROFILE_FUNCTION();
if(m_pool == VK_NULL_HANDLE)
return;
for(auto& set : m_free_sets)
kvfDestroyDescriptorSetLayout(RenderCore::Get().GetDevice(), set->m_set_layout);
for(auto& set : m_used_sets)
kvfDestroyDescriptorSetLayout(RenderCore::Get().GetDevice(), set->m_set_layout);
RenderCore::Get().vkDestroyDescriptorPool(RenderCore::Get().GetDevice(), m_pool, nullptr);
m_pool = VK_NULL_HANDLE;
m_allocation_count = 0;
m_free_sets.clear();
m_used_sets.clear();
}
VkDescriptorSet DescriptorPool::AllocateDescriptorSet(std::uint32_t frame_index, VkDescriptorSetLayout layout)
std::shared_ptr<DescriptorSet> DescriptorPool::RequestDescriptorSet(const ShaderSetLayout& layout, ShaderType shader_type)
{
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++;
MLX_PROFILE_FUNCTION();
auto it = std::find_if(m_free_sets.begin(), m_free_sets.end(), [&](std::shared_ptr<DescriptorSet> set)
{
return shader_type == set->GetShaderType() && layout == set->GetShaderLayout();
});
if(it != m_free_sets.end())
{
std::shared_ptr<DescriptorSet> set = *it;
m_free_sets.erase(it);
m_used_sets.push_back(set);
return set;
}
std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> vulkan_sets;
VkShaderStageFlagBits vulkan_shader_stage;
switch(shader_type)
{
case ShaderType::Vertex: vulkan_shader_stage = VK_SHADER_STAGE_VERTEX_BIT; break;
case ShaderType::Fragment: vulkan_shader_stage = VK_SHADER_STAGE_FRAGMENT_BIT; break;
default : FatalError("wtf"); break;
}
std::vector<VkDescriptorSetLayoutBinding> bindings(layout.binds.size());
for(std::size_t i = 0; i < layout.binds.size(); i++)
{
bindings[i].binding = layout.binds[i].first;
bindings[i].descriptorCount = 1;
bindings[i].descriptorType = layout.binds[i].second;
bindings[i].pImmutableSamplers = nullptr;
bindings[i].stageFlags = vulkan_shader_stage;
}
VkDescriptorSetLayout vulkan_layout = kvfCreateDescriptorSetLayout(RenderCore::Get().GetDevice(), bindings.data(), bindings.size());
for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
{
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 = &vulkan_layout;
VkDescriptorSet vulkan_set;
kvfCheckVk(RenderCore::Get().vkAllocateDescriptorSets(RenderCore::Get().GetDevice(), &alloc_info, &vulkan_set));
m_allocation_count++;
vulkan_sets[i] = vulkan_set;
}
std::shared_ptr<DescriptorSet> set(new DescriptorSet(*this, vulkan_layout, layout, std::move(vulkan_sets), shader_type));
m_used_sets.push_back(set);
return set;
}
void DescriptorPool::ResetPoolFromFrameIndex(std::size_t frame_index)
void DescriptorPool::ReturnDescriptorSet(std::shared_ptr<class DescriptorSet> set)
{
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);
auto it = std::find_if(m_used_sets.begin(), m_used_sets.end(), [&](std::shared_ptr<DescriptorSet> rhs_set)
{
return set == rhs_set;
});
if(it == m_used_sets.end())
{
Error("Vulkan : cannot return descriptor set to pool, invalid pool");
return;
}
m_used_sets.erase(it);
m_free_sets.push_back(set);
}
DescriptorPool& DescriptorPoolManager::GetAvailablePool()
{
MLX_PROFILE_FUNCTION();
for(auto& pool : m_pools)
{
if(pool.GetNumberOfSetsAllocated() < MAX_SETS_PER_POOL)
return pool;
}
m_pools.emplace_front().Init();
return m_pools.front();
m_pools.emplace_back().Init();
return m_pools.back();
}
void DescriptorPoolManager::Destroy()
{
MLX_PROFILE_FUNCTION();
#pragma omp parallel for
for(auto& pool : m_pools)
pool.Destroy();
m_pools.clear();
}
DescriptorSet::DescriptorSet(DescriptorPoolManager& pools_manager, const ShaderSetLayout& layout, VkDescriptorSetLayout vklayout, ShaderType shader_type)
: m_set_layout(vklayout), p_pools_manager(&pools_manager)
DescriptorSet::DescriptorSet(DescriptorPool& pool, VkDescriptorSetLayout vulkan_layout, const ShaderSetLayout& layout, std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> vulkan_sets, ShaderType shader_type) :
m_shader_layout(layout),
m_sets(std::move(vulkan_sets)),
m_set_layout(vulkan_layout),
m_shader_type(shader_type),
m_pool(pool)
{
MLX_PROFILE_FUNCTION();
for(auto& [binding, type] : layout.binds)
{
m_descriptors.emplace_back();
m_descriptors.back().type = type;
m_descriptors.back().shader_type = shader_type;
m_descriptors.back().binding = binding;
}
for(std::size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
m_set[i] = p_pools_manager->GetAvailablePool().AllocateDescriptorSet(i, vklayout);
}
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] = p_pools_manager->GetAvailablePool().AllocateDescriptorSet(i, layout);
}
void DescriptorSet::SetImage(std::size_t i, std::uint32_t binding, class Image& image)
{
MLX_PROFILE_FUNCTION();
Verify(m_set[i] != VK_NULL_HANDLE, "invalid descriptor");
Verify(m_sets[i] != VK_NULL_HANDLE, "invalid descriptor");
auto it = std::find_if(m_descriptors.begin(), m_descriptors.end(), [=](Descriptor descriptor)
{
return binding == descriptor.binding;
@@ -151,7 +196,7 @@ namespace mlx
void DescriptorSet::SetStorageBuffer(std::size_t i, std::uint32_t binding, class GPUBuffer& buffer)
{
MLX_PROFILE_FUNCTION();
Verify(m_set[i] != VK_NULL_HANDLE, "invalid descriptor");
Verify(m_sets[i] != VK_NULL_HANDLE, "invalid descriptor");
auto it = std::find_if(m_descriptors.begin(), m_descriptors.end(), [=](Descriptor descriptor)
{
return binding == descriptor.binding;
@@ -172,7 +217,7 @@ namespace mlx
void DescriptorSet::SetUniformBuffer(std::size_t i, std::uint32_t binding, class GPUBuffer& buffer)
{
MLX_PROFILE_FUNCTION();
Verify(m_set[i] != VK_NULL_HANDLE, "invalid descriptor");
Verify(m_sets[i] != VK_NULL_HANDLE, "invalid descriptor");
auto it = std::find_if(m_descriptors.begin(), m_descriptors.end(), [=](Descriptor descriptor)
{
return binding == descriptor.binding;
@@ -193,7 +238,7 @@ namespace mlx
void DescriptorSet::Update(std::size_t i, VkCommandBuffer cmd) noexcept
{
MLX_PROFILE_FUNCTION();
Verify(m_set[i] != VK_NULL_HANDLE, "invalid descriptor");
Verify(m_sets[i] != VK_NULL_HANDLE, "invalid descriptor");
std::vector<VkWriteDescriptorSet> writes;
std::vector<VkDescriptorBufferInfo> buffer_infos;
std::vector<VkDescriptorImageInfo> image_infos;
@@ -207,7 +252,7 @@ namespace mlx
info.imageLayout = descriptor.image_ptr->GetLayout();
info.imageView = descriptor.image_ptr->GetImageView();
image_infos.push_back(info);
writes.push_back(kvfWriteImageToDescriptorSet(RenderCore::Get().GetDevice(), m_set[i], &image_infos.back(), descriptor.binding));
writes.push_back(kvfWriteImageToDescriptorSet(RenderCore::Get().GetDevice(), m_sets[i], &image_infos.back(), descriptor.binding));
}
else if(descriptor.uniform_buffer_ptr)
{
@@ -216,7 +261,7 @@ namespace mlx
info.offset = descriptor.uniform_buffer_ptr->GetOffset();
info.range = VK_WHOLE_SIZE;
buffer_infos.push_back(info);
writes.push_back(kvfWriteUniformBufferToDescriptorSet(RenderCore::Get().GetDevice(), m_set[i], &buffer_infos.back(), descriptor.binding));
writes.push_back(kvfWriteUniformBufferToDescriptorSet(RenderCore::Get().GetDevice(), m_sets[i], &buffer_infos.back(), descriptor.binding));
}
else if(descriptor.storage_buffer_ptr)
{
@@ -225,16 +270,14 @@ namespace mlx
info.offset = descriptor.storage_buffer_ptr->GetOffset();
info.range = VK_WHOLE_SIZE;
buffer_infos.push_back(info);
writes.push_back(kvfWriteStorageBufferToDescriptorSet(RenderCore::Get().GetDevice(), m_set[i], &buffer_infos.back(), descriptor.binding));
writes.push_back(kvfWriteStorageBufferToDescriptorSet(RenderCore::Get().GetDevice(), m_sets[i], &buffer_infos.back(), descriptor.binding));
}
}
RenderCore::Get().vkUpdateDescriptorSets(RenderCore::Get().GetDevice(), writes.size(), writes.data(), 0, nullptr);
}
void DescriptorSet::Reallocate(std::size_t frame_index) noexcept
void DescriptorSet::ReturnDescriptorSetToPool()
{
MLX_PROFILE_FUNCTION();
Assert(!p_pools_manager, "invalid pools manager");
m_set[frame_index] = p_pools_manager->GetAvailablePool().AllocateDescriptorSet(frame_index, m_set_layout);
m_pool.ReturnDescriptorSet(shared_from_this());
}
}