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

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 4f755f8a6f
commit 0304834008
28 changed files with 302 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
runtime/Includes/Core/Enums.h
View File

@@ -19,7 +19,6 @@ namespace mlx
enum class Event
{
DescriptorPoolResetEventCode = 55,
ResizeEventCode = 56,
FrameBeginEventCode = 57,
FatalErrorEventCode = 168,

2
runtime/Includes/Core/Graphics.h
View File

@@ -44,6 +44,8 @@ namespace mlx
std::shared_ptr<Window> p_window;
std::unique_ptr<Scene> p_scene;
std::uint64_t m_draw_layer = 0;
int m_id;
bool m_has_window;

8
runtime/Includes/Core/Graphics.inl
View File

@@ -9,6 +9,7 @@ namespace mlx
p_scene->ResetSprites();
m_put_pixel_manager.ResetRenderData();
m_insert_new_pixel_put_texture = true;
m_draw_layer = 0;
}
void GraphicsSupport::PixelPut(int x, int y, std::uint32_t color) noexcept
@@ -19,6 +20,7 @@ namespace mlx
{
Sprite& new_sprite = p_scene->CreateSprite(texture);
new_sprite.SetPosition(Vec2f{ 0.0f, 0.0f });
m_draw_layer++;
}
m_insert_new_pixel_put_texture = false;
}
@@ -42,8 +44,12 @@ namespace mlx
new_sprite.SetPosition(Vec2f{ static_cast<float>(x), static_cast<float>(y) });
m_insert_new_pixel_put_texture = true;
}
else
else if(!p_scene->IsTextureAtGivenDrawLayer(texture, m_draw_layer))
{
p_scene->BringToFront(std::move(sprite));
m_insert_new_pixel_put_texture = true;
}
m_draw_layer++;
}
void GraphicsSupport::LoadFont(const std::filesystem::path& filepath, float scale)

15
runtime/Includes/Graphics/Mesh.h
View File

@@ -48,6 +48,21 @@ namespace mlx
private:
std::vector<SubMesh> m_sub_meshes;
};
class MeshRegistry
{
public:
MeshRegistry() = default;
inline void RegisterMesh(std::shared_ptr<Mesh> mesh);
inline void UnregisterMesh(std::shared_ptr<Mesh> mesh);
inline bool IsMeshKnown(std::shared_ptr<Mesh> mesh);
~MeshRegistry() = default;
private:
std::unordered_set<std::shared_ptr<Mesh>> m_mesh_registry;
};
}
#endif

11
runtime/Includes/Graphics/Scene.h
View File

@@ -7,32 +7,25 @@
namespace mlx
{
struct SceneDescriptor
{
NonOwningPtr<Renderer> renderer;
// More description may come in future
};
class Scene
{
public:
Scene(SceneDescriptor desc);
Scene() = default;
Sprite& CreateSprite(NonOwningPtr<class Texture> texture) noexcept;
NonOwningPtr<Sprite> GetSpriteFromTextureAndPosition(NonOwningPtr<Texture> texture, const Vec2f& position) const;
void BringToFront(NonOwningPtr<Sprite> sprite);
void TryEraseSpriteFromTexture(NonOwningPtr<Texture> texture);
bool IsTextureAtGivenDrawLayer(NonOwningPtr<Texture> texture, std::uint64_t draw_layer) const;
inline void ResetSprites() { m_sprites.clear(); }
[[nodiscard]] MLX_FORCEINLINE const std::vector<std::shared_ptr<Sprite>>& GetSprites() const noexcept { return m_sprites; }
[[nodiscard]] MLX_FORCEINLINE const SceneDescriptor& GetDescription() const noexcept { return m_descriptor; }
[[nodiscard]] MLX_FORCEINLINE ViewerData& GetViewerData() noexcept { return m_viewer_data; }
~Scene() = default;
private:
SceneDescriptor m_descriptor;
std::vector<std::shared_ptr<Sprite>> m_sprites;
ViewerData m_viewer_data;
};

20
runtime/Includes/Graphics/Sprite.h
View File

@@ -14,7 +14,7 @@ namespace mlx
friend class Render2DPass;
public:
Sprite(class Renderer& renderer, NonOwningPtr<Texture> texture);
Sprite(NonOwningPtr<Texture> texture);
inline void SetColor(Vec4f color) noexcept { m_color = color; }
inline void SetPosition(Vec2f position) noexcept { m_position = position; }
@@ -24,25 +24,27 @@ namespace mlx
[[nodiscard]] MLX_FORCEINLINE std::shared_ptr<Mesh> GetMesh() const { return p_mesh; }
[[nodiscard]] MLX_FORCEINLINE NonOwningPtr<Texture> GetTexture() const { return p_texture; }
~Sprite() = default;
inline ~Sprite() { if(p_set) p_set->ReturnDescriptorSetToPool(); }
private:
[[nodiscard]] inline bool IsSetInit() const noexcept { return m_set.IsInit(); }
[[nodiscard]] inline VkDescriptorSet GetSet(std::size_t frame_index) const noexcept { return m_set.GetSet(frame_index); }
[[nodiscard]] inline bool IsSetInit() const noexcept { return p_set && p_set->IsInit(); }
[[nodiscard]] inline VkDescriptorSet GetSet(std::size_t frame_index) const noexcept { return p_set ? p_set->GetSet(frame_index) : VK_NULL_HANDLE; }
inline void UpdateDescriptorSet(const DescriptorSet& set)
inline void UpdateDescriptorSet(std::shared_ptr<DescriptorSet> set)
{
m_set = set.Duplicate();
p_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(set->GetShaderLayout(), set->GetShaderType());
}
inline void Bind(std::size_t frame_index, VkCommandBuffer cmd)
{
m_set.SetImage(frame_index, 0, *p_texture);
m_set.Update(frame_index, cmd);
if(!p_set)
return;
p_set->SetImage(frame_index, 0, *p_texture);
p_set->Update(frame_index, cmd);
}
private:
DescriptorSet m_set;
std::shared_ptr<DescriptorSet> p_set;
NonOwningPtr<Texture> p_texture;
std::shared_ptr<Mesh> p_mesh;
Vec4f m_color = Vec4f{ 1.0f, 1.0f, 1.0f, 1.0f };

41
runtime/Includes/Renderer/Descriptor.h
View File

@@ -13,7 +13,6 @@ namespace mlx
NonOwningPtr<class GPUBuffer> uniform_buffer_ptr;
NonOwningPtr<class Image> image_ptr;
VkDescriptorType type;
ShaderType shader_type;
std::uint32_t binding;
};
@@ -25,17 +24,18 @@ namespace mlx
void Init() noexcept;
void Destroy() noexcept;
VkDescriptorSet AllocateDescriptorSet(std::uint32_t frame_index, VkDescriptorSetLayout layout);
std::shared_ptr<class DescriptorSet> RequestDescriptorSet(const ShaderSetLayout& layout, ShaderType shader_type);
void ReturnDescriptorSet(std::shared_ptr<class DescriptorSet> set);
void ResetPoolFromFrameIndex(std::size_t frame_index);
[[nodiscard]] inline VkDescriptorPool Get(std::uint32_t index) const noexcept { return m_pools[index]; }
[[nodiscard]] inline VkDescriptorPool Get() const noexcept { return m_pool; }
[[nodiscard]] MLX_FORCEINLINE std::size_t GetNumberOfSetsAllocated() const noexcept { return m_allocation_count; }
~DescriptorPool() = default;
private:
std::array<VkDescriptorPool, MAX_FRAMES_IN_FLIGHT> m_pools;
std::vector<std::shared_ptr<class DescriptorSet>> m_free_sets;
std::vector<std::shared_ptr<class DescriptorSet>> m_used_sets;
VkDescriptorPool m_pool;
std::size_t m_allocation_count = 0;
};
@@ -44,42 +44,45 @@ namespace mlx
public:
DescriptorPoolManager() = default;
void ResetPoolsFromFrameIndex(std::size_t frame_index);
DescriptorPool& GetAvailablePool();
void Destroy();
~DescriptorPoolManager() = default;
private:
std::list<DescriptorPool> m_pools;
std::vector<DescriptorPool> m_pools;
};
class DescriptorSet
class DescriptorSet : public std::enable_shared_from_this<DescriptorSet>
{
public:
DescriptorSet() { m_set.fill(VK_NULL_HANDLE); }
DescriptorSet(DescriptorPoolManager& pools_manager, const ShaderSetLayout& layout, VkDescriptorSetLayout vklayout, ShaderType shader_type);
friend DescriptorPool;
public:
void SetImage(std::size_t i, std::uint32_t binding, class Image& image);
void SetStorageBuffer(std::size_t i, std::uint32_t binding, class GPUBuffer& buffer);
void SetUniformBuffer(std::size_t i, std::uint32_t binding, class GPUBuffer& buffer);
void Update(std::size_t i, VkCommandBuffer cmd = VK_NULL_HANDLE) noexcept;
void Reallocate(std::size_t frame_index) noexcept;
[[nodiscard]] inline VkDescriptorSet GetSet(std::size_t i) const noexcept { return m_set[i]; }
[[nodiscard]] inline DescriptorSet Duplicate() const { return DescriptorSet{ *p_pools_manager, m_set_layout, m_descriptors }; }
[[nodiscard]] inline bool IsInit() const noexcept { return m_set[0] != VK_NULL_HANDLE; }
void ReturnDescriptorSetToPool();
[[nodiscard]] inline VkDescriptorSet GetSet(std::size_t i) const noexcept { return m_sets[i]; }
[[nodiscard]] MLX_FORCEINLINE bool IsInit() const noexcept { return m_sets[0] != VK_NULL_HANDLE; }
[[nodiscard]] MLX_FORCEINLINE VkDescriptorSetLayout GetVulkanLayout() const noexcept { return m_set_layout; }
[[nodiscard]] MLX_FORCEINLINE const ShaderSetLayout& GetShaderLayout() const { return m_shader_layout; }
[[nodiscard]] MLX_FORCEINLINE ShaderType GetShaderType() const noexcept { return m_shader_type; }
~DescriptorSet() = default;
private:
DescriptorSet(DescriptorPoolManager& pools_manager, VkDescriptorSetLayout layout, const std::vector<Descriptor>& descriptors);
DescriptorSet(DescriptorPool& pool, VkDescriptorSetLayout vulkan_layout, const ShaderSetLayout& layout, std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> vulkan_sets, ShaderType shader_type);
private:
ShaderSetLayout m_shader_layout;
std::vector<Descriptor> m_descriptors;
std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> m_set;
std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> m_sets;
VkDescriptorSetLayout m_set_layout;
NonOwningPtr<DescriptorPoolManager> p_pools_manager;
ShaderType m_shader_type;
DescriptorPool& m_pool;
};
}

7
runtime/Includes/Renderer/Enums.h
View File

@@ -17,11 +17,16 @@ namespace mlx
enum class ImageType
{
Color = 0,
Depth,
EndEnum
};
constexpr std::size_t ImageTypeCount = static_cast<std::size_t>(ImageType::EndEnum);
enum class ShaderType
{
Vertex,
Fragment
};
}
#endif

1
runtime/Includes/Renderer/Image.h
View File

@@ -77,6 +77,7 @@ namespace mlx
}
void Init(CPUBuffer pixels, std::uint32_t width, std::uint32_t height, VkFormat format, bool is_multisampled, [[maybe_unused]] std::string_view debug_name);
void Destroy() noexcept override;
void SetPixel(int x, int y, std::uint32_t color) noexcept;
int GetPixel(int x, int y) noexcept;

15
runtime/Includes/Renderer/Pipelines/Shader.h
View File

@@ -1,13 +1,17 @@
#ifndef __MLX_SHADER__
#define __MLX_SHADER__
#include <Renderer/Enums.h>
namespace mlx
{
struct ShaderSetLayout
{
std::vector<std::pair<int, VkDescriptorType> > binds;
std::vector<std::pair<int, VkDescriptorType>> binds;
ShaderSetLayout(std::vector<std::pair<int, VkDescriptorType> > b) : binds(std::move(b)) {}
inline bool operator==(const ShaderSetLayout& rhs) const { return binds == rhs.binds; }
};
struct ShaderPushConstantLayout
@@ -20,19 +24,12 @@ namespace mlx
struct ShaderLayout
{
std::vector<std::pair<int, ShaderSetLayout> > set_layouts;
std::vector<std::pair<int, ShaderSetLayout>> set_layouts;
std::vector<ShaderPushConstantLayout> push_constants;
ShaderLayout(std::vector<std::pair<int, ShaderSetLayout> > s, std::vector<ShaderPushConstantLayout> pc) : set_layouts(std::move(s)), push_constants(std::move(pc)) {}
};
enum class ShaderType
{
Vertex,
Fragment,
Compute
};
struct ShaderPipelineLayoutPart
{
std::vector<VkPushConstantRange> push_constants;

7
runtime/Includes/Renderer/RenderCore.h
View File

@@ -1,12 +1,13 @@
#ifndef __MLX_RENDER_CORE__
#define __MLX_RENDER_CORE__
constexpr const int MAX_FRAMES_IN_FLIGHT = 3;
#include <Renderer/Memory.h>
#include <Renderer/Descriptor.h>
namespace mlx
{
constexpr const int MAX_FRAMES_IN_FLIGHT = 3;
#if defined(DEBUG) && defined(VK_EXT_debug_utils)
#define MLX_HAS_DEBUG_UTILS_FUNCTIONS
#endif
@@ -21,6 +22,7 @@ namespace mlx
[[nodiscard]] MLX_FORCEINLINE VkDevice GetDevice() const noexcept { return m_device; }
[[nodiscard]] MLX_FORCEINLINE VkPhysicalDevice GetPhysicalDevice() const noexcept { return m_physical_device; }
[[nodiscard]] MLX_FORCEINLINE GPUAllocator& GetAllocator() noexcept { return m_allocator; }
[[nodiscard]] inline DescriptorPoolManager& GetDescriptorPoolManager() noexcept { return m_descriptor_pool_manager; }
inline void WaitDeviceIdle() const noexcept { vkDeviceWaitIdle(m_device); }
@@ -45,6 +47,7 @@ namespace mlx
private:
static RenderCore* s_instance;
DescriptorPoolManager m_descriptor_pool_manager;
GPUAllocator m_allocator;
VkInstance m_instance = VK_NULL_HANDLE;
VkDevice m_device = VK_NULL_HANDLE;

2
runtime/Includes/Renderer/RenderPasses/2DPass.h
View File

@@ -1,7 +1,7 @@
#ifndef __MLX_2D_PASS__
#define __MLX_2D_PASS__
#include <Renderer/Descriptor.h>
#include <Renderer/RenderCore.h>
#include <Renderer/Pipelines/Shader.h>
#include <Renderer/Pipelines/Graphics.h>

2
runtime/Includes/Renderer/RenderPasses/FinalPass.h
View File

@@ -1,7 +1,7 @@
#ifndef __MLX_FINAL_PASS__
#define __MLX_FINAL_PASS__
#include <Renderer/Descriptor.h>
#include <Renderer/RenderCore.h>
#include <Renderer/Pipelines/Shader.h>
#include <Renderer/Pipelines/Graphics.h>

3
runtime/Includes/Renderer/Renderer.h
View File

@@ -5,7 +5,6 @@
#include <Utils/NonOwningPtr.h>
#include <Renderer/RenderCore.h>
#include <Renderer/Image.h>
#include <Renderer/Descriptor.h>
#include <Core/EventBus.h>
namespace mlx
@@ -32,7 +31,6 @@ namespace mlx
[[nodiscard]] inline std::size_t GetSwapchainImageIndex() const noexcept { return m_swapchain_image_index; }
[[nodiscard]] inline std::size_t GetCurrentFrameIndex() const noexcept { return m_current_frame_index; }
[[nodiscard]] inline NonOwningPtr<Window> GetWindow() const noexcept { return p_window; }
[[nodiscard]] inline DescriptorPoolManager& GetDescriptorPoolManager() noexcept { return m_descriptor_pool_manager; }
MLX_FORCEINLINE constexpr void RequireFramebufferResize() noexcept { m_framebuffers_resize = true; }
@@ -45,7 +43,6 @@ namespace mlx
void DestroySwapchain();
private:
DescriptorPoolManager m_descriptor_pool_manager;
std::array<VkSemaphore, MAX_FRAMES_IN_FLIGHT> m_image_available_semaphores;
std::array<VkSemaphore, MAX_FRAMES_IN_FLIGHT> m_render_finished_semaphores;
std::array<VkCommandBuffer, MAX_FRAMES_IN_FLIGHT> m_cmd_buffers;

33
runtime/Includes/Utils/CallOnExit.h git.filemode.normal_file
View File

@@ -0,0 +1,33 @@
#ifndef __MLX_CALL_ON_EXIT__
#define __MLX_CALL_ON_EXIT__
namespace mlx
{
template <typename F>
class CallOnExit
{
public:
CallOnExit() = default;
CallOnExit(F&& functor);
CallOnExit(const CallOnExit&) = delete;
CallOnExit(CallOnExit&&) = delete;
void CallAndReset();
void Reset();
CallOnExit& operator=(const CallOnExit&) = delete;
CallOnExit& operator=(CallOnExit&&) = default;
~CallOnExit();
private:
std::optional<F> m_functor;
};
template<typename F>
CallOnExit(F) -> CallOnExit<F>;
}
#include <Utils/CallOnExit.inl>
#endif

29
runtime/Includes/Utils/CallOnExit.inl git.filemode.normal_file
View File

@@ -0,0 +1,29 @@
#pragma once
#include <Utils/CallOnExit.h>
namespace mlx
{
template<typename F>
CallOnExit<F>::CallOnExit(F&& functor) : m_functor(std::move(functor)) {}
template<typename F>
CallOnExit<F>::~CallOnExit()
{
if(m_functor.has_value())
(*m_functor)();
}
template<typename F>
void CallOnExit<F>::CallAndReset()
{
if(m_functor.has_value())
(*m_functor)();
m_functor.reset();
}
template<typename F>
void CallOnExit<F>::Reset()
{
m_functor.reset();
}
}

6
runtime/Sources/Core/Application.cpp
View File

@@ -10,7 +10,7 @@ namespace mlx
{
Application::Application() : p_mem_manager(std::make_unique<MemManager>()), p_sdl_manager(std::make_unique<SDLManager>()), m_fps(), m_in()
{
EventBus::RegisterListener({[](const EventBase& event)
EventBus::RegisterListener({ [](const EventBase& event)
{
if(event.What() == Event::FatalErrorEventCode)
std::abort();
@@ -53,7 +53,7 @@ namespace mlx
MLX_PROFILE_FUNCTION();
Texture* texture;
try { texture = new Texture({}, w, h, VK_FORMAT_R8G8B8A8_SRGB, false, "mlx_user_image"); }
catch(...) { return NULL; }
catch(...) { return nullptr; }
m_image_registry.RegisterTexture(texture);
return texture;
}
@@ -63,7 +63,7 @@ namespace mlx
MLX_PROFILE_FUNCTION();
Texture* texture = StbTextureLoad(file, w, h);
if(texture == nullptr)
return NULL; // NULL for C compatibility
return nullptr;
m_image_registry.RegisterTexture(texture);
return texture;
}

13
runtime/Sources/Core/Graphics.cpp
View File

@@ -13,10 +13,7 @@ namespace mlx
// TODO : re-enable render targets
m_renderer.Init(nullptr);
m_scene_renderer.Init(m_renderer);
SceneDescriptor descriptor{};
descriptor.renderer = &m_renderer;
p_scene = std::make_unique<Scene>(std::move(descriptor));
p_scene = std::make_unique<Scene>();
}
GraphicsSupport::GraphicsSupport(std::size_t w, std::size_t h, std::string title, int id) :
@@ -28,10 +25,7 @@ namespace mlx
MLX_PROFILE_FUNCTION();
m_renderer.Init(p_window.get());
m_scene_renderer.Init(m_renderer);
SceneDescriptor descriptor{};
descriptor.renderer = &m_renderer;
p_scene = std::make_unique<Scene>(std::move(descriptor));
p_scene = std::make_unique<Scene>();
}
void GraphicsSupport::Render() noexcept
@@ -39,6 +33,7 @@ namespace mlx
MLX_PROFILE_FUNCTION();
if(m_renderer.BeginFrame())
{
m_draw_layer = 0;
m_scene_renderer.Render(*p_scene, m_renderer);
m_renderer.EndFrame();
}
@@ -47,7 +42,7 @@ namespace mlx
// dump memory to file every two seconds
using namespace std::chrono_literals;
static std::int64_t timer = static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
if(std::chrono::duration<std::uint64_t>{static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count()) - timer} >= 1s)
if(std::chrono::duration<std::uint64_t>{ static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count()) - timer } >= 1s)
{
RenderCore::Get().GetAllocator().DumpMemoryToJson();
timer = static_cast<std::uint64_t>(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());

4
runtime/Sources/Graphics/PutPixelManager.cpp
View File

@@ -19,9 +19,13 @@ namespace mlx
#endif
texture.Clear(VK_NULL_HANDLE, Vec4f{ 0.0f });
}
if(!m_textures.empty())
{
m_textures.back().SetPixel(x, y, color);
return (insert_new_texture ? &m_textures.back() : nullptr);
}
return nullptr;
}
void PutPixelManager::ResetRenderData()
{

17
runtime/Sources/Graphics/Scene.cpp
View File

@@ -5,17 +5,10 @@
namespace mlx
{
Scene::Scene(SceneDescriptor desc)
: m_descriptor(std::move(desc))
{
MLX_PROFILE_FUNCTION();
Verify((bool)m_descriptor.renderer, "invalid renderer");
}
Sprite& Scene::CreateSprite(NonOwningPtr<Texture> texture) noexcept
{
MLX_PROFILE_FUNCTION();
std::shared_ptr<Sprite> sprite = std::make_shared<Sprite>(*m_descriptor.renderer, texture);
std::shared_ptr<Sprite> sprite = std::make_shared<Sprite>(texture);
m_sprites.push_back(sprite);
return *sprite;
}
@@ -52,7 +45,15 @@ namespace mlx
{
return sprite->GetTexture() == texture;
});
if(it != m_sprites.end())
m_sprites.erase(it);
} while(it != m_sprites.end());
}
bool Scene::IsTextureAtGivenDrawLayer(NonOwningPtr<Texture> texture, std::uint64_t draw_layer) const
{
if(draw_layer >= m_sprites.size())
return false;
return m_sprites[draw_layer]->GetTexture() == texture;
}
}

9
runtime/Sources/Graphics/Sprite.cpp
View File

@@ -37,18 +37,11 @@ namespace mlx
return mesh;
}
Sprite::Sprite(Renderer& renderer, NonOwningPtr<Texture> texture)
Sprite::Sprite(NonOwningPtr<Texture> texture)
{
MLX_PROFILE_FUNCTION();
Verify((bool)texture, "Sprite: invalid texture (internal mlx issue, please report to devs)");
p_mesh = CreateQuad(0, 0, texture->GetWidth(), texture->GetHeight());
p_texture = texture;
func::function<void(const EventBase&)> functor = [this, &renderer](const EventBase& event)
{
if(event.What() == Event::DescriptorPoolResetEventCode)
m_set.Reallocate(renderer.GetCurrentFrameIndex());
};
EventBus::RegisterListener({ functor, "__MlxSprite" + std::to_string(reinterpret_cast<std::uintptr_t>(this)) });
}
}

155
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;
}
void DescriptorPool::ResetPoolFromFrameIndex(std::size_t frame_index)
std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> vulkan_sets;
VkShaderStageFlagBits vulkan_shader_stage;
switch(shader_type)
{
Assert(frame_index < MAX_FRAMES_IN_FLIGHT, "invalid frame index");
RenderCore::Get().vkResetDescriptorPool(RenderCore::Get().GetDevice(), m_pools[frame_index], 0);
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;
}
void DescriptorPoolManager::ResetPoolsFromFrameIndex(std::size_t frame_index)
std::vector<VkDescriptorSetLayoutBinding> bindings(layout.binds.size());
for(std::size_t i = 0; i < layout.binds.size(); i++)
{
for(auto& pool : m_pools)
pool.ResetPoolFromFrameIndex(frame_index);
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::ReturnDescriptorSet(std::shared_ptr<class DescriptorSet> set)
{
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());
}
}

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

@@ -2,6 +2,7 @@
#include <Renderer/Image.h>
#include <Maths/Vec4.h>
#include <Renderer/RenderCore.h>
#include <Utils/CallOnExit.h>
#define STB_IMAGE_IMPLEMENTATION
#ifdef MLX_COMPILER_GCC
@@ -80,14 +81,7 @@ namespace mlx
bool is_single_time_cmd_buffer = (cmd == VK_NULL_HANDLE);
if(is_single_time_cmd_buffer)
cmd = kvfCreateCommandBuffer(RenderCore::Get().GetDevice());
KvfImageType kvf_type = KVF_IMAGE_OTHER;
switch(m_type)
{
case ImageType::Color: kvf_type = KVF_IMAGE_COLOR; break;
case ImageType::Depth: kvf_type = KVF_IMAGE_DEPTH; break;
default: break;
}
kvfTransitionImageLayout(RenderCore::Get().GetDevice(), m_image, kvf_type, cmd, m_format, m_layout, new_layout, is_single_time_cmd_buffer);
kvfTransitionImageLayout(RenderCore::Get().GetDevice(), m_image, KVF_IMAGE_COLOR, cmd, m_format, m_layout, new_layout, is_single_time_cmd_buffer);
m_layout = new_layout;
}
@@ -109,18 +103,9 @@ namespace mlx
VkImageLayout old_layout = m_layout;
TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, cmd);
if(m_type == ImageType::Color)
{
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);
}
else if(m_type == ImageType::Depth)
{
VkClearDepthStencilValue clear_depth_stencil = { 1.0f, 1 };
subresource_range.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
RenderCore::Get().vkCmdClearDepthStencilImage(cmd, m_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_depth_stencil, 1, &subresource_range);
}
TransitionLayout(old_layout, cmd);
if(is_single_time_cmd_buffer)
@@ -189,6 +174,13 @@ namespace mlx
TransitionLayout(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
}
void Texture::Destroy() noexcept
{
if(m_staging_buffer.has_value())
m_staging_buffer->Destroy();
Image::Destroy();
}
void Texture::SetPixel(int x, int y, std::uint32_t color) noexcept
{
MLX_PROFILE_FUNCTION();
@@ -266,6 +258,9 @@ namespace mlx
MLX_PROFILE_FUNCTION();
std::string filename = file.string();
if(file.stem() == "banana")
Message("banana, banana, banana, banana, terracotta banana terracotta, terracotta pie");
if(!std::filesystem::exists(file))
{
Error("Image : file not found %", file);
@@ -280,14 +275,15 @@ namespace mlx
int dummy_h;
int channels;
std::uint8_t* data = stbi_load(filename.c_str(), (w == nullptr ? &dummy_w : w), (h == nullptr ? &dummy_h : h), &channels, 4);
CallOnExit defer([=]() { stbi_image_free(data); });
CPUBuffer buffer((w == nullptr ? dummy_w : *w) * (h == nullptr ? dummy_h : *h) * 4);
std::memcpy(buffer.GetData(), data, buffer.GetSize());
Texture* texture;
try { texture = new Texture(buffer, (w == nullptr ? dummy_w : *w), (h == nullptr ? dummy_h : *h), VK_FORMAT_R8G8B8A8_SRGB, false, std::move(filename)); }
catch(...) { return NULL; }
stbi_image_free(data);
try { texture = new Texture(std::move(buffer), (w == nullptr ? dummy_w : *w), (h == nullptr ? dummy_h : *h), VK_FORMAT_R8G8B8A8_SRGB, false, std::move(filename)); }
catch(...) { return nullptr; }
return texture;
}
}

1
runtime/Sources/Renderer/Pipelines/Shader.cpp
View File

@@ -11,7 +11,6 @@ namespace mlx
{
case ShaderType::Vertex : m_stage = VK_SHADER_STAGE_VERTEX_BIT; break;
case ShaderType::Fragment : m_stage = VK_SHADER_STAGE_FRAGMENT_BIT; break;
case ShaderType::Compute : m_stage = VK_SHADER_STAGE_COMPUTE_BIT; break;
default : FatalError("wtf"); break;
}

5
runtime/Sources/Renderer/RenderCore.cpp
View File

@@ -47,6 +47,8 @@ namespace mlx
RenderCore::RenderCore()
{
if(s_instance != nullptr)
return;
s_instance = this;
loader = std::make_unique<VulkanLoader>();
@@ -193,7 +195,10 @@ namespace mlx
RenderCore::~RenderCore()
{
if(s_instance == nullptr)
return;
WaitDeviceIdle();
m_descriptor_pool_manager.Destroy();
m_allocator.Destroy();
kvfDestroyDevice(m_device);
DebugLog("Vulkan : logical device destroyed");

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

@@ -45,23 +45,15 @@ 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, &renderer](const EventBase& event)
func::function<void(const EventBase&)> functor = [this](const EventBase& event)
{
if(event.What() == Event::ResizeEventCode)
m_pipeline.Destroy();
if(event.What() == Event::DescriptorPoolResetEventCode)
{
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>(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_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_vertex_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Vertex);
p_texture_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_fragment_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Fragment);
p_viewer_data_buffer = std::make_shared<UniformBuffer>();
p_viewer_data_buffer->Init(sizeof(ViewerData), "mlx_2d_pass_viewer_data");
@@ -106,7 +98,7 @@ namespace mlx
{
// Check every textures and update modified ones to GPU before starting the render pass
if(!sprite->IsSetInit())
sprite->UpdateDescriptorSet(*p_texture_set);
sprite->UpdateDescriptorSet(p_texture_set);
Verify((bool)sprite->GetTexture(), "a sprite has no texture attached (internal mlx issue, please report to the devs)");
sprite->GetTexture()->Update(cmd);
}
@@ -136,8 +128,10 @@ namespace mlx
m_pipeline.Destroy();
p_vertex_shader.reset();
p_fragment_shader.reset();
p_viewer_data_set->ReturnDescriptorSetToPool();
p_viewer_data_set.reset();
p_viewer_data_buffer->Destroy();
p_texture_set->ReturnDescriptorSetToPool();
p_texture_set.reset();
}
}

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

@@ -31,16 +31,14 @@ 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, &renderer](const EventBase& event)
func::function<void(const EventBase&)> functor = [this](const EventBase& event)
{
if(event.What() == Event::ResizeEventCode)
m_pipeline.Destroy();
if(event.What() == Event::DescriptorPoolResetEventCode)
p_set->Reallocate(renderer.GetCurrentFrameIndex());
};
EventBus::RegisterListener({ functor, "__MlxFinalPass" });
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);
p_set = RenderCore::Get().GetDescriptorPoolManager().GetAvailablePool().RequestDescriptorSet(p_fragment_shader->GetShaderLayout().set_layouts[0].second, ShaderType::Fragment);
}
void FinalPass::Pass([[maybe_unused]] Scene& scene, Renderer& renderer, Texture& render_target)
@@ -80,6 +78,7 @@ namespace mlx
m_pipeline.Destroy();
p_vertex_shader.reset();
p_fragment_shader.reset();
p_set->ReturnDescriptorSetToPool();
p_set.reset();
}
}

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

@@ -18,11 +18,6 @@ namespace mlx
{
Event What() const override { return Event::FrameBeginEventCode; }
};
struct DescriptorPoolResetEventBroadcast : public EventBase
{
Event What() const override { return Event::DescriptorPoolResetEventCode; }
};
}
void Renderer::Init(NonOwningPtr<Window> window)
@@ -59,13 +54,6 @@ 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)
{
@@ -150,7 +138,6 @@ 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");