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

adding descriptors support to renderer

Browse Source
This commit is contained in:
kbz_8
2023-01-23 19:27:37 +01:00
parent c8302b4fdf
commit 006d665ce2
13 changed files with 346 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Makefile
View File

@@ -6,7 +6,7 @@
# By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ # # By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ # # +#+#+#+#+#+ +#+ #
# Created: 2022/10/04 16:43:41 by maldavid #+# #+# # # Created: 2022/10/04 16:43:41 by maldavid #+# #+# #
# Updated: 2022/12/19 00:06:48 by maldavid ### ########.fr # # Updated: 2023/01/23 18:30:59 by maldavid ### ########.fr #
# # # #
# **************************************************************************** # # **************************************************************************** #
@@ -44,7 +44,6 @@ $(NAME): $(OBJS)
clean: clean:
@$(RM) $(OBJS) @$(RM) $(OBJS)
@$(RM) $(OBJS_B)
fclean: clean fclean: clean
@$(RM) $(NAME) @$(RM) $(NAME)

4
src/platform/window.cpp
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/04 17:36:44 by maldavid #+# #+# */ /* Created: 2022/10/04 17:36:44 by maldavid #+# #+# */
/* Updated: 2022/12/19 15:53:35 by maldavid ### ########.fr */ /* Updated: 2023/01/22 18:53:41 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -31,7 +31,7 @@ namespace mlx
_renderer->init(); _renderer->init();
_vbo.create(sizeof(Vertex)); _vbo.create(sizeof(Vertex));
proj = glm::ortho<float>(_width, 0, _height, 0); proj = glm::ortho<float>(0, _width, 0, _height);
} }
bool MLX_Window::beginFrame() bool MLX_Window::beginFrame()

63
src/renderer/buffers/vk_ubo.cpp
View File

@@ -6,29 +6,68 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:45:52 by maldavid #+# #+# */ /* Created: 2022/10/06 18:45:52 by maldavid #+# #+# */
/* Updated: 2022/12/18 00:25:55 by maldavid ### ########.fr */ /* Updated: 2023/01/23 18:54:12 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "vk_ubo.h" #include "vk_ubo.h"
#include <cstring> #include <cstring>
#include <renderer/renderer.h>
namespace mlx namespace mlx
{ {
void UBO::setData(uint32_t size, const void* data) void UBO::create(Renderer* renderer, uint32_t size)
{ {
void* temp = nullptr; _renderer = renderer;
mapMem(&temp);
std::memcpy(temp, data, static_cast<size_t>(size)); for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
unmapMem(); {
_buffers[i].create(Buffer::kind::uniform, size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT);
_buffers[i].mapMem(&_maps[i]);
if(_maps[i] == nullptr)
core::error::report(e_kind::fatal_error, "Vulkan : unable to map a uniform buffer");
}
} }
void UBO::setDynamicData(uint32_t size, uint32_t typeSize, const void* data) void UBO::setData(uint32_t size, const void* data)
{ {
void* temp = nullptr; std::memcpy(_maps[_renderer->getActiveImageIndex()], data, static_cast<size_t>(size));
mapMem(&temp); }
std::memcpy(temp, data, static_cast<size_t>(size));
Buffer::flush(); void UBO::setDynamicData(uint32_t size, const void* data)
unmapMem(); {
std::memcpy(_maps[_renderer->getActiveImageIndex()], data, static_cast<size_t>(size));
_buffers[_renderer->getActiveImageIndex()].flush();
}
unsigned int UBO::getSize() noexcept
{
return _buffers[_renderer->getActiveImageIndex()].getSize();
}
unsigned int UBO::getOffset() noexcept
{
return _buffers[_renderer->getActiveImageIndex()].getOffset();
}
VkDeviceMemory UBO::getDeviceMemory() noexcept
{
return _buffers[_renderer->getActiveImageIndex()].getDeviceMemory();
}
VkBuffer& UBO::operator()() noexcept
{
return _buffers[_renderer->getActiveImageIndex()].get();
}
VkBuffer& UBO::get() noexcept
{
return _buffers[_renderer->getActiveImageIndex()].get();
}
void UBO::destroy() noexcept
{
for(int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
_buffers[i].destroy();
} }
} }

29
src/renderer/buffers/vk_ubo.h
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:45:29 by maldavid #+# #+# */ /* Created: 2022/10/06 18:45:29 by maldavid #+# #+# */
/* Updated: 2022/10/06 18:45:49 by maldavid ### ########.fr */ /* Updated: 2023/01/23 18:54:08 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -14,16 +14,37 @@
#define __MLX_VK_UBO__ #define __MLX_VK_UBO__
#include "vk_buffer.h" #include "vk_buffer.h"
#include <array>
#include <cstddef>
namespace mlx namespace mlx
{ {
class UBO : public Buffer class UBO
{ {
public: public:
inline void create(uint32_t size) { Buffer::create(Buffer::kind::dynamic, size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT); } void create(class Renderer* renderer, uint32_t size);
void setData(uint32_t size, const void* data); void setData(uint32_t size, const void* data);
void setDynamicData(uint32_t size, uint32_t typeSize, const void* data); void setDynamicData(uint32_t size, const void* data);
void destroy() noexcept;
unsigned int getSize() noexcept;
unsigned int getOffset() noexcept;
VkDeviceMemory getDeviceMemory() noexcept;
VkBuffer& operator()() noexcept;
VkBuffer& get() noexcept;
inline unsigned int getSize(int i) noexcept { return _buffers[i].getSize(); }
inline unsigned int getOffset(int i) noexcept { return _buffers[i].getOffset(); }
inline VkDeviceMemory getDeviceMemory(int i) noexcept { return _buffers[i].getDeviceMemory(); }
inline VkBuffer& operator()(int i) noexcept { return _buffers[i].get(); }
inline VkBuffer& get(int i) noexcept { return _buffers[i].get(); }
private:
std::array<Buffer, MAX_FRAMES_IN_FLIGHT> _buffers;
std::array<void*, MAX_FRAMES_IN_FLIGHT> _maps;
class Renderer* _renderer = nullptr;
}; };
} }

4
src/renderer/core/render_core.cpp
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/17 23:33:34 by maldavid #+# #+# */ /* Created: 2022/12/17 23:33:34 by maldavid #+# #+# */
/* Updated: 2022/12/19 14:08:57 by maldavid ### ########.fr */ /* Updated: 2023/01/23 18:28:12 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -71,8 +71,10 @@ namespace mlx
volkInitialize(); volkInitialize();
_instance.init(); _instance.init();
volkLoadInstance(_instance.get());
_layers.init(); _layers.init();
_device.init(); _device.init();
volkLoadDevice(_device.get());
_queues.init(); _queues.init();
_is_init = true; _is_init = true;
} }

34
src/renderer/descriptors/vk_descriptor_pool.cpp git.filemode.normal_file
View File

@@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_descriptor_pool.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:34:23 by maldavid #+# #+# */
/* Updated: 2023/01/23 18:44:51 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include "vk_descriptor_pool.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 = 8192;
if(vkCreateDescriptorPool(Render_Core::get().getDevice().get(), &poolInfo, nullptr, &_pool) != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : failed to create descriptor pool");
}
void DescriptorPool::destroy() noexcept
{
vkDestroyDescriptorPool(Render_Core::get().getDevice().get(), _pool, nullptr);
}
}

35
src/renderer/descriptors/vk_descriptor_pool.h git.filemode.normal_file
View File

@@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_descriptor_pool.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:32:43 by maldavid #+# #+# */
/* Updated: 2023/01/23 18:44:40 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __VK_DESCRIPTOR_POOL__
#define __VK_DESCRIPTOR_POOL__
#include <volk.h>
#include <cstddef>
namespace mlx
{
class DescriptorPool
{
public:
void init(std::size_t n, VkDescriptorPoolSize* size);
void destroy() noexcept;
inline VkDescriptorPool& operator()() noexcept { return _pool; }
inline VkDescriptorPool& get() noexcept { return _pool; }
private:
VkDescriptorPool _pool = VK_NULL_HANDLE;
};
}
#endif

74
src/renderer/descriptors/vk_descriptor_set.cpp git.filemode.normal_file
View File

@@ -0,0 +1,74 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_descriptor_set.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:40:44 by maldavid #+# #+# */
/* Updated: 2023/01/23 18:54:28 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include "vk_descriptor_set.h"
#include "vk_descriptor_pool.h"
#include "vk_descriptor_set_layout.h"
#include <renderer/buffers/vk_ubo.h>
#include <renderer/renderer.h>
namespace mlx
{
void DescriptorSet::init(Renderer* renderer, UBO* ubo, DescriptorSetLayout& layout, DescriptorPool& pool)
{
_renderer = renderer;
auto device = Render_Core::get().getDevice().get();
_pool = pool.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;
allocInfo.descriptorSetCount = MAX_FRAMES_IN_FLIGHT;
allocInfo.pSetLayouts = layouts.data();
if(vkAllocateDescriptorSets(device, &allocInfo, _desc_set.data()) != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : failed to allocate descriptor set");
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 = 0;
descriptorWrite.dstArrayElement = 0;
descriptorWrite.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
descriptorWrite.descriptorCount = 1;
descriptorWrite.pBufferInfo = &bufferInfo;
vkUpdateDescriptorSets(device, 1, &descriptorWrite, 0, nullptr);
}
}
VkDescriptorSet& DescriptorSet::operator()() noexcept
{
return _desc_set[_renderer->getActiveImageIndex()];
}
VkDescriptorSet& DescriptorSet::get() noexcept
{
return _desc_set[_renderer->getActiveImageIndex()];
}
void DescriptorSet::destroy() noexcept
{
vkFreeDescriptorSets(Render_Core::get().getDevice().get(), _pool, MAX_FRAMES_IN_FLIGHT, _desc_set.data());
}
}

38
src/renderer/descriptors/vk_descriptor_set.h git.filemode.normal_file
View File

@@ -0,0 +1,38 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_descriptor_set.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:39:36 by maldavid #+# #+# */
/* Updated: 2023/01/23 18:54:22 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __VK_DESCRIPTOR_SET__
#define __VK_DESCRIPTOR_SET__
#include <volk.h>
#include <array>
#include <renderer/core/render_core.h>
namespace mlx
{
class DescriptorSet
{
public:
void init(class Renderer* renderer, class UBO* ubo, class DescriptorSetLayout& layout, class DescriptorPool& pool);
void destroy() noexcept;
VkDescriptorSet& operator()() noexcept;
VkDescriptorSet& get() noexcept;
private:
std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> _desc_set;
VkDescriptorPool _pool = VK_NULL_HANDLE;
class Renderer* _renderer = nullptr;
};
}
#endif

40
src/renderer/descriptors/vk_descriptor_set_layout.cpp git.filemode.normal_file
View File

@@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_descriptor_set_layout.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:37:28 by maldavid #+# #+# */
/* Updated: 2023/01/23 18:45:32 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include "vk_descriptor_set_layout.h"
#include <renderer/core/render_core.h>
namespace mlx
{
void DescriptorSetLayout::init(VkDescriptorType t, std::size_t n, int binding, VkShaderStageFlagBits stage)
{
VkDescriptorSetLayoutBinding bindings{};
bindings.binding = binding;
bindings.descriptorCount = 1;
bindings.descriptorType = t;
bindings.pImmutableSamplers = nullptr;
bindings.stageFlags = stage;
VkDescriptorSetLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutInfo.bindingCount = n;
layoutInfo.pBindings = &bindings;
if(vkCreateDescriptorSetLayout(Render_Core::get().getDevice().get(), &layoutInfo, nullptr, &_layout) != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : failed to create descriptor set layout");
}
void DescriptorSetLayout::destroy() noexcept
{
vkDestroyDescriptorSetLayout(Render_Core::get().getDevice().get(), _layout, nullptr);
}
}

35
src/renderer/descriptors/vk_descriptor_set_layout.h git.filemode.normal_file
View File

@@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_descriptor_set_layout.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:36:22 by maldavid #+# #+# */
/* Updated: 2023/01/23 18:45:44 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __VK_DESCRIPTOR_SET_LAYOUT__
#define __VK_DESCRIPTOR_SET_LAYOUT__
#include <volk.h>
#include <cstddef>
namespace mlx
{
class DescriptorSetLayout
{
public:
void init(VkDescriptorType t = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, std::size_t n = 1, int binding = 0, VkShaderStageFlagBits stage = VK_SHADER_STAGE_VERTEX_BIT);
void destroy() noexcept;
inline VkDescriptorSetLayout& operator()() noexcept { return _layout; }
inline VkDescriptorSetLayout& get() noexcept { return _layout; }
private:
VkDescriptorSetLayout _layout = VK_NULL_HANDLE;
};
}
#endif

8
src/renderer/renderer.h
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/18 17:14:45 by maldavid #+# #+# */ /* Created: 2022/12/18 17:14:45 by maldavid #+# #+# */
/* Updated: 2022/12/18 22:15:50 by maldavid ### ########.fr */ /* Updated: 2023/01/23 19:08:29 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -25,6 +25,9 @@
#include <renderer/command/vk_cmd_buffer.h> #include <renderer/command/vk_cmd_buffer.h>
#include <renderer/swapchain/vk_swapchain.h> #include <renderer/swapchain/vk_swapchain.h>
#include <renderer/swapchain/vk_render_pass.h> #include <renderer/swapchain/vk_render_pass.h>
#include <renderer/descriptors/vk_descriptor_set.h>
#include <renderer/descriptors/vk_descriptor_pool.h>
#include <renderer/descriptors/vk_descriptor_set_layout.h>
#include <core/errors.h> #include <core/errors.h>
@@ -101,6 +104,9 @@ namespace mlx
CmdPool _cmd_pool; CmdPool _cmd_pool;
SwapChain _swapchain; SwapChain _swapchain;
Semaphore _semaphore; Semaphore _semaphore;
DescriptorPool _desc_pool;
std::vector<DescriptorSet> _sets;
std::vector<DescriptorSetLayout> _layouts;
std::array<CmdBuffer, MAX_FRAMES_IN_FLIGHT> _cmd_buffers; std::array<CmdBuffer, MAX_FRAMES_IN_FLIGHT> _cmd_buffers;
class MLX_Window* _window; class MLX_Window* _window;

7
test/main.c
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */ /* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/04 17:55:21 by maldavid #+# #+# */ /* Created: 2022/10/04 17:55:21 by maldavid #+# #+# */
/* Updated: 2022/12/19 15:52:54 by maldavid ### ########.fr */ /* Updated: 2023/01/22 18:17:53 by maldavid ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@@ -25,11 +25,6 @@ int update(t_mlx *mlx)
printf("%d\n", i); printf("%d\n", i);
mlx_pixel_put(mlx->mlx, mlx->win, 200, 50, 0xFF0000); mlx_pixel_put(mlx->mlx, mlx->win, 200, 50, 0xFF0000);
mlx_pixel_put(mlx->mlx, mlx->win, 200, 60, 0x00FF00);
mlx_pixel_put(mlx->mlx, mlx->win, 200, 70, 0x0000FF);
mlx_pixel_put(mlx->mlx, mlx->win, 200, 80, 0xFF00FF);
mlx_pixel_put(mlx->mlx, mlx->win, 200, 90, 0xFFFF00);
mlx_pixel_put(mlx->mlx, mlx->win, 200, 100, 0xFFFFFF);
i++; i++;
if (i > 20000) if (i > 20000)
mlx_loop_end(mlx->mlx); mlx_loop_end(mlx->mlx);