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

big refactoring ! ci skip

Browse Source
This commit is contained in:
Kbz-8
2024-09-02 09:44:42 +02:00
parent 7ecee717f8
commit d5eeef9559
581 changed files with 42971 additions and 99170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
runtime/Includes/Renderer/Buffer.h git.filemode.normal_file
View File

@@ -0,0 +1,83 @@
#ifndef __MLX_GPU_BUFFER__
#define __MLX_GPU_BUFFER__
#include <Renderer/Enums.h>
#include <Renderer/RenderCore.h>
#include <Utils/Buffer.h>
namespace mlx
{
class GPUBuffer
{
public:
GPUBuffer() = default;
void Init(BufferType type, VkDeviceSize size, VkBufferUsageFlags usage, CPUBuffer data);
void Destroy() noexcept;
bool CopyFrom(const GPUBuffer& buffer) noexcept;
void Swap(GPUBuffer& buffer) noexcept;
[[nodiscard]] MLX_FORCEINLINE void* GetMap() const noexcept { return m_memory.map; }
[[nodiscard]] MLX_FORCEINLINE VkBuffer Get() const noexcept { return m_buffer; }
[[nodiscard]] MLX_FORCEINLINE VkDeviceMemory GetMemory() const noexcept { return m_memory.memory; }
[[nodiscard]] MLX_FORCEINLINE VkDeviceSize GetSize() const noexcept { return m_memory.size; }
[[nodiscard]] MLX_FORCEINLINE VkDeviceSize GetOffset() const noexcept { return 0; }
[[nodiscard]] inline bool IsInit() const noexcept { return m_buffer != VK_NULL_HANDLE; }
~GPUBuffer() = default;
protected:
void PushToGPU() noexcept;
protected:
VkBuffer m_buffer = VK_NULL_HANDLE;
VmaAllocation m_allocation;
VkDeviceSize m_offset = 0;
VkDeviceSize m_size = 0;
void* p_map = nullptr;
private:
void CreateBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VmaAllocationCreateInfo alloc_info);
private:
VkBufferUsageFlags m_usage = 0;
};
class VertexBuffer : public GPUBuffer
{
public:
inline void Init(std::uint32_t size, VkBufferUsageFlags additional_flags = 0) { GPUBuffer::Init(BufferType::LowDynamic, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | additional_flags, {}); }
void SetData(CPUBuffer data);
inline void Bind(VkCommandBuffer cmd) const noexcept { VkDeviceSize offset = 0; vkCmdBindVertexBuffers(cmd, 0, 1, &m_buffer, &offset); }
};
class IndexBuffer : public GPUBuffer
{
public:
inline void Init(std::uint32_t size, VkBufferUsageFlags additional_flags = 0) { GPUBuffer::Init(BufferType::LowDynamic, size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT | additional_flags, {}); }
void SetData(CPUBuffer data);
inline void Bind(VkCommandBuffer cmd) const noexcept { vkCmdBindIndexBuffer(cmd, m_buffer, 0, VK_INDEX_TYPE_UINT32); }
};
class UniformBuffer
{
public:
void Init(std::uint32_t size);
void SetData(CPUBuffer data, std::size_t frame_index);
void Destroy() noexcept;
inline VkDeviceSize GetSize(int i) const noexcept { return m_buffers[i].GetSize(); }
inline VkDeviceSize GetOffset(int i) const noexcept { return m_buffers[i].GetOffset(); }
inline VkBuffer GetVk(int i) const noexcept { return m_buffers[i].Get(); }
inline GPUBuffer& Get(int i) noexcept { return m_buffers[i]; }
private:
std::array<GPUBuffer, MAX_FRAMES_IN_FLIGHT> m_buffers;
std::array<void*, MAX_FRAMES_IN_FLIGHT> m_maps;
};
}
#endif

66
runtime/Includes/Renderer/Buffers/Buffer.h
View File

@@ -1,66 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Buffer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 23:18:52 by maldavid #+# #+# */
/* Updated: 2024/04/23 14:20:49 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_BUFFER__
#define __MLX_VK_BUFFER__
#include <Renderer/Enums.h>
#include <Renderer/Core/RenderCore.h>
#include <Renderer/Command/CommandResource.h>
namespace mlx
{
class Buffer : public CommandResource
{
public:
Buffer() = default;
void Create(BufferType type, VkDeviceSize size, VkBufferUsageFlags usage, const char* name, const void* data = nullptr);
void Destroy() noexcept;
inline void MapMem(void** data) noexcept { RenderCore::Get().GetAllocator().MapMemory(m_allocation, data); m_is_mapped = true; }
inline bool IsMapped() const noexcept { return m_is_mapped; }
inline void UnmapMem() noexcept { RenderCore::Get().GetAllocator().UnmapMemory(m_allocation); m_is_mapped = false; }
void Flush(VkDeviceSize size = VK_WHOLE_SIZE, VkDeviceSize offset = 0);
bool CopyFromBuffer(const Buffer& buffer) noexcept;
inline VkBuffer& operator()() noexcept { return m_buffer; }
inline VkBuffer& Get() noexcept { return m_buffer; }
inline VkDeviceSize GetSize() const noexcept { return m_size; }
inline VkDeviceSize GetOffset() const noexcept { return m_offset; }
~Buffer() = default;
protected:
void PushToGPU() noexcept;
void Swap(Buffer& buffer) noexcept;
protected:
VmaAllocation m_allocation;
VkBuffer m_buffer = VK_NULL_HANDLE;
VkDeviceSize m_offset = 0;
VkDeviceSize m_size = 0;
private:
void CreateBuffer(VkBufferUsageFlags usage, VmaAllocationCreateInfo info, VkDeviceSize size, const char* name);
private:
#ifdef DEBUG
std::string m_name;
#endif
VkBufferUsageFlags m_usage = 0;
bool m_is_mapped = false;
};
}
#endif

29
runtime/Includes/Renderer/Buffers/IndexBuffer.h
View File

@@ -1,29 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* IndexBuffer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/25 15:05:05 by maldavid #+# #+# */
/* Updated: 2024/07/05 13:24:46 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __VK_IBO__
#define __VK_IBO__
#include <Renderer/Buffers/Buffer.h>
#include <Renderer/Renderer.h>
namespace mlx
{
class ConstantIndexBuffer : public Buffer
{
public:
inline void Create(std::uint32_t size, const std::uint16_t* data, const char* name) { Buffer::Create(BufferType::Constant, size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, name, data); }
inline void Bind(Renderer& renderer) noexcept { renderer.GetActiveCmdBuffer().BindIndexBuffer(*this); }
};
}
#endif

50
runtime/Includes/Renderer/Buffers/UniformBuffer.h
View File

@@ -1,50 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* UniformBuffer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:45:29 by maldavid #+# #+# */
/* Updated: 2024/07/05 13:39:32 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_UBO__
#define __MLX_VK_UBO__
#include <Renderer/Buffers/Buffer.h>
namespace mlx
{
class UniformBuffer
{
public:
UniformBuffer() = default;
void Create(NonOwningPtr<class Renderer> renderer, std::uint32_t size, const char* name);
void Destroy() noexcept;
void SetData(std::uint32_t size, const void* data);
VkDeviceSize GetSize() noexcept;
VkDeviceSize GetOffset() noexcept;
VkDeviceMemory GetDeviceMemory() noexcept;
VkBuffer& operator()() noexcept;
VkBuffer& Get() noexcept;
inline VkDeviceSize GetSize(int i) noexcept { return m_buffers[i].GetSize(); }
inline VkDeviceSize GetOffset(int i) noexcept { return m_buffers[i].GetOffset(); }
inline VkBuffer& operator()(int i) noexcept { return m_buffers[i].Get(); }
inline VkBuffer& Get(int i) noexcept { return m_buffers[i].Get(); }
~UniformBuffer() = default;
private:
std::array<Buffer, MAX_FRAMES_IN_FLIGHT> m_buffers;
std::array<void*, MAX_FRAMES_IN_FLIGHT> m_maps;
NonOwningPtr<class Renderer> p_renderer;
};
}
#endif // __MLX_VK_UBO__

46
runtime/Includes/Renderer/Buffers/VertexBuffer.h
View File

@@ -1,46 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* VertexBuffer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:27:38 by maldavid #+# #+# */
/* Updated: 2024/07/05 13:24:41 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_VBO__
#define __MLX_VK_VBO__
#include <Renderer/Enums.h>
#include <Renderer/Buffers/Buffer.h>
#include <Renderer/Renderer.h>
namespace mlx
{
class RAMVertexBuffer : public Buffer
{
public:
inline void Create(std::uint32_t size, const void* data, const char* name) { Buffer::Create(BufferType::HighDynamic, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); }
void SetData(std::uint32_t size, const void* data);
inline void Bind(Renderer& renderer) noexcept { renderer.GetActiveCmdBuffer().BindVertexBuffer(*this); }
};
class DeviceVertexBuffer : public Buffer
{
public:
inline void create(std::uint32_t size, const void* data, const char* name) { Buffer::Create(BufferType::LowDynamic, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); }
void SetData(std::uint32_t size, const void* data);
inline void Bind(Renderer& renderer) noexcept { renderer.GetActiveCmdBuffer().BindVertexBuffer(*this); }
};
class ConstantVertexBuffer : public Buffer
{
public:
inline void Create(std::uint32_t size, const void* data, const char* name) { Buffer::Create(BufferType::Constant, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); }
inline void Bind(Renderer& renderer) noexcept { renderer.GetActiveCmdBuffer().BindVertexBuffer(*this); }
};
}
#endif // __MLX_VK_VBO__

70
runtime/Includes/Renderer/Command/CommandBuffer.h
View File

@@ -1,70 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* CommandBuffer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:25:42 by maldavid #+# #+# */
/* Updated: 2024/07/05 13:37:54 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_CMD_BUFFER__
#define __MLX_VK_CMD_BUFFER__
#include <Renderer/Core/Fence.h>
#include <Renderer/Enums.h>
namespace mlx
{
class Buffer;
class Image;
class CommandBuffer
{
public:
void Init(CommandBufferType type, NonOwningPtr<class CommandManager> manager);
void Init(CommandBufferType type, NonOwningPtr<class CommandPool> pool);
void Destroy() noexcept;
void BeginRecord(VkCommandBufferUsageFlags usage = 0);
void Submit(NonOwningPtr<class Semaphore> signal, NonOwningPtr<class Semaphore> wait) noexcept;
void SubmitIdle(bool shouldWaitForExecution = true) noexcept; // TODO : handle `shouldWaitForExecution` as false by default (needs to modify CmdResources lifetimes to do so)
void UpdateSubmitState() noexcept;
inline void WaitForExecution() noexcept { m_fence.Wait(); UpdateSubmitState(); m_state = CommandBufferState::Ready; }
inline void Reset() noexcept { vkResetCommandBuffer(m_cmd_buffer, 0); }
void EndRecord();
void BindVertexBuffer(Buffer& buffer) noexcept;
void BindIndexBuffer(Buffer& buffer) noexcept;
void CopyBuffer(Buffer& dst, Buffer& src) noexcept;
void CopyBufferToImage(Buffer& buffer, Image& image) noexcept;
void CopyImagetoBuffer(Image& image, Buffer& buffer) noexcept;
void TransitionImageLayout(Image& image, VkImageLayout new_layout) noexcept;
inline bool IsInit() const noexcept { return m_state != CommandBufferState::Uninit; }
inline bool IsReadyToBeUsed() const noexcept { return m_state == CommandBufferState::Ready; }
inline bool IsRecording() const noexcept { return m_state == CommandBufferState::Recording; }
inline bool HasBeenSubmitted() const noexcept { return m_state == CommandBufferState::Submitted; }
inline CommandBufferState GetCurrentState() const noexcept { return m_state; }
inline VkCommandBuffer& operator()() noexcept { return m_cmd_buffer; }
inline VkCommandBuffer& Get() noexcept { return m_cmd_buffer; }
inline Fence& GetFence() noexcept { return m_fence; }
private:
void PreTransferBarrier() noexcept;
void PostTransferBarrier() noexcept;
private:
std::vector<NonOwningPtr<class CommandResource>> m_cmd_resources;
Fence m_fence;
VkCommandBuffer m_cmd_buffer = VK_NULL_HANDLE;
NonOwningPtr<class CmdPool> m_pool;
CommandBufferState m_state = CommandBufferState::Uninit;
CommandBufferType m_type;
};
}
#endif // __MLX_VK_CMD_BUFFER__

43
runtime/Includes/Renderer/Command/CommandManager.h
View File

@@ -1,43 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* CommandManager.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/02 17:48:52 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:20:53 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_COMMAND_MANAGER__
#define __MLX_COMMAND_MANAGER__
#include <Renderer/Core/RenderCore.h>
#include <Renderer/Command/CommandPool.h>
#include <Renderer/Command/CommandBuffer.h>
namespace mlx
{
class CommandManager
{
public:
CommandManager() = default;
void Init() noexcept;
void BeginRecord(int active_image_index);
void EndRecord(int active_image_index);
void Destroy() noexcept;
inline CommandPool& GetCmdPool() noexcept { return m_cmd_pool; }
inline CommandBuffer& GetCmdBuffer(int i) noexcept { return m_cmd_buffers[i]; }
~CommandManager() = default;
private:
std::array<CommandBuffer, MAX_FRAMES_IN_FLIGHT> m_cmd_buffers;
CommandPool m_cmd_pool;
};
}
#endif

36
runtime/Includes/Renderer/Command/CommandPool.h
View File

@@ -1,36 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* CommandPool.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:24:12 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:33:15 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_CMD_POOL__
#define __MLX_VK_CMD_POOL__
namespace mlx
{
class CommandPool
{
public:
CommandPool() = default;
void Init();
void Destroy() noexcept;
inline VkCommandPool& operator()() noexcept { return m_cmd_pool; }
inline VkCommandPool& Get() noexcept { return m_cmd_pool; }
~CommandPool() = default;
private:
VkCommandPool m_cmd_pool = VK_NULL_HANDLE;
};
}
#endif // __MLX_VK_CMD_POOL__

38
runtime/Includes/Renderer/Command/CommandResource.h
View File

@@ -1,38 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* CommandResource.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/12/16 20:44:29 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:37:06 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_COMMAND_RESOURCE__
#define __MLX_COMMAND_RESOURCE__
#include <Renderer/Enums.h>
#include <Core/UUID.h>
namespace mlx
{
class CommandResource
{
friend class SingleTimeCmdManager;
public:
CommandResource() : m_uuid() {}
inline void RecordedInCmdBuffer() noexcept { m_state = CommandResourceState::Held; }
inline void RemovedFromCmdBuffer() noexcept { m_state = CommandResourceState::Free; }
inline UUID GetUUID() const noexcept { return m_uuid; }
virtual ~CommandResource() = default;
private:
UUID m_uuid;
CommandResourceState m_state = CommandResourceState::Free;
};
}
#endif

49
runtime/Includes/Renderer/Command/SingleTimeCmdManager.h
View File

@@ -1,49 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* SingleTimeCmdManager.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/12/15 18:25:57 by maldavid #+# #+# */
/* Updated: 2024/07/05 13:38:11 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_SINGLE_TIME_CMD_MANAGER__
#define __MLX_SINGLE_TIME_CMD_MANAGER__
#include <Renderer/Command/CommandBuffer.h>
#include <Renderer/Command/CommandPool.h>
namespace mlx
{
class CommandBuffer;
class SingleTimeCmdManager
{
friend class RenderCore;
public:
SingleTimeCmdManager() = default;
void Init() noexcept;
void Destroy() noexcept;
void UpdateSingleTimesCmdBuffersSubmitState() noexcept;
void WaitForAllExecutions() noexcept;
inline CommandPool& GetCmdPool() noexcept { return m_pool; }
CommandBuffer& GetCmdBuffer() noexcept;
~SingleTimeCmdManager() = default;
inline static constexpr const std::uint8_t BASE_POOL_SIZE = 16;
private:
std::vector<CommandBuffer> m_buffers;
CommandPool m_pool;
};
}
#endif

40
runtime/Includes/Renderer/Core/Device.h
View File

@@ -1,40 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Device.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 19:13:42 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:47:21 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_DEVICE__
#define __MLX_VK_DEVICE__
namespace mlx
{
class Device
{
public:
void Init();
void Destroy() noexcept;
inline VkDevice& operator()() noexcept { return m_device; }
inline VkDevice& Get() noexcept { return m_device; }
inline VkPhysicalDevice& GetPhysicalDevice() noexcept { return m_physical_device; }
private:
void PickPhysicalDevice();
bool CheckDeviceExtensionSupport(VkPhysicalDevice device);
int DeviceScore(VkPhysicalDevice device);
private:
VkPhysicalDevice m_physical_device = VK_NULL_HANDLE;
VkDevice m_device = VK_NULL_HANDLE;
};
}
#endif // __MLX_VK_DEVICE__

28
runtime/Includes/Renderer/Core/DrawableResource.h
View File

@@ -1,28 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* DrawableResource.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/10 21:00:37 by maldavid #+# #+# */
/* Updated: 2024/04/23 18:10:56 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_DRAWABLE_RESOURCE__
#define __MLX_DRAWABLE_RESOURCE__
namespace mlx
{
class DrawableResource
{
public:
DrawableResource() = default;
virtual void Render(class Renderer& renderer) = 0;
virtual void ResetUpdate() {}
virtual ~DrawableResource() = default;
};
}
#endif

40
runtime/Includes/Renderer/Core/Fence.h
View File

@@ -1,40 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Fence.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/02 17:52:09 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:48:31 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_FENCE__
#define __MLX_VK_FENCE__
namespace mlx
{
class Fence
{
public:
Fence() = default;
void Init();
inline VkFence& Get() noexcept { return m_fence; }
void Wait() noexcept;
void Reset() noexcept;
bool IsReady() const noexcept;
MLX_FORCEINLINE void WaitAndReset() noexcept { Wait(); Reset(); }
void Destroy() noexcept;
~Fence() = default;
private:
VkFence m_fence = VK_NULL_HANDLE;
};
}
#endif

38
runtime/Includes/Renderer/Core/Instance.h
View File

@@ -1,38 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Instance.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 19:03:04 by maldavid #+# #+# */
/* Updated: 2024/04/23 18:44:02 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_INSTANCE__
#define __MLX_VK_INSTANCE__
namespace mlx
{
class Instance
{
public:
void Init();
void Destroy() noexcept;
inline std::uint32_t GetInstanceVersion() const noexcept { return m_instance_version; }
inline VkInstance& operator()() noexcept { return m_instance; }
inline VkInstance& Get() noexcept { return m_instance; }
private:
std::vector<const char*> GetRequiredExtensions();
private:
VkInstance m_instance = VK_NULL_HANDLE;
std::uint32_t m_instance_version = 0;
};
}
#endif // __MLX_VK_INSTANCE__

51
runtime/Includes/Renderer/Core/Queues.h
View File

@@ -1,51 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Queues.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 19:01:49 by maldavid #+# #+# */
/* Updated: 2024/07/05 13:38:50 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_QUEUES__
#define __MLX_VK_QUEUES__
namespace mlx
{
class Queues
{
public:
struct QueueFamilyIndices
{
std::optional<std::uint32_t> graphics_family;
std::optional<std::uint32_t> present_family;
inline bool IsComplete() { return graphics_family.has_value() && present_family.has_value(); }
};
public:
QueueFamilyIndices FindQueueFamilies(VkPhysicalDevice device);
void Init();
inline VkQueue& GetGraphic() noexcept { return m_graphics_queue; }
inline VkQueue& GetPresent() noexcept { return m_present_queue; }
inline QueueFamilyIndices GetFamilies() noexcept
{
if(m_families.has_value())
return *m_families;
FatalError("Vulkan : cannot get queue families, not init");
return {}; // just to avoid warnings
}
private:
VkQueue m_graphics_queue;
VkQueue m_present_queue;
std::optional<QueueFamilyIndices> m_families;
};
}
#endif // __MLX_VK_QUEUES__

78
runtime/Includes/Renderer/Core/RenderCore.h
View File

@@ -1,78 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* RenderCore.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 19:16:32 by maldavid #+# #+# */
/* Updated: 2024/07/05 13:39:11 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_RENDER_CORE__
#define __MLX_RENDER_CORE__
#include <Renderer/Command/SingleTimeCmdManager.h>
#include <Renderer/Descriptors/DescriptorPoolManager.h>
#include <Renderer/Descriptors/DescriptorPool.h>
#include <Renderer/Core/Queues.h>
#include <Renderer/Core/Device.h>
#include <Renderer/Core/Instance.h>
#include <Renderer/Core/ValidationLayers.h>
#include <Renderer/Core/Memory.h>
#include <Utils/Singleton.h>
namespace mlx
{
const char* VerbaliseVkResult(VkResult result);
VkPipelineStageFlags AccessFlagsToPipelineStage(VkAccessFlags access_flags, VkPipelineStageFlags stage_flags);
#ifdef DEBUG
constexpr const bool enable_validation_layers = true;
#else
constexpr const bool enable_validation_layers = false;
#endif
const std::vector<const char*> validation_layers = { "VK_LAYER_KHRONOS_validation" };
constexpr const int MAX_FRAMES_IN_FLIGHT = 3;
constexpr const int MAX_SETS_PER_POOL = 512;
constexpr const int NUMBER_OF_UNIFORM_BUFFERS = 1; // change this if for wathever reason more than one uniform buffer is needed
class RenderCore : public Singleton<RenderCore>
{
friend class Singleton<RenderCore>;
public:
void Init();
void Destroy();
inline bool IsInit() const noexcept { return m_is_init; }
inline Instance& GetInstance() noexcept { return m_instance; }
inline Device& GetDevice() noexcept { return m_device; }
inline Queues& GetQueue() noexcept { return m_queues; }
inline GPUallocator& GetAllocator() noexcept { return m_allocator; }
inline ValidationLayers& GetLayers() noexcept { return m_layers; }
inline CommandBuffer& GetSingleTimeCmdBuffer() noexcept { return m_cmd_manager.GetCmdBuffer(); }
inline SingleTimeCmdManager& GetSingleTimeCmdManager() noexcept { return m_cmd_manager; }
inline DescriptorPool& GetDescriptorPool() { return m_pool_manager.GetAvailablePool(); }
private:
RenderCore() = default;
~RenderCore() = default;
private:
ValidationLayers m_layers;
SingleTimeCmdManager m_cmd_manager;
Queues m_queues;
DescriptorPoolManager m_pool_manager;
Device m_device;
Instance m_instance;
GPUallocator m_allocator;
bool m_is_init = false;
};
}
#endif // __MLX_RENDER_CORE__

31
runtime/Includes/Renderer/Core/Semaphore.h
View File

@@ -1,31 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Semaphore.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 18:59:38 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:56:51 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_SEMAPHORE__
#define __MLX_VK_SEMAPHORE__
namespace mlx
{
class Semaphore
{
public:
void Init();
void Destroy() noexcept;
inline VkSemaphore& Get() noexcept { return m_semaphore; }
private:
VkSemaphore m_semaphore = VK_NULL_HANDLE;
};
}
#endif // __MLX_VK_SEMAPHORE__

34
runtime/Includes/Renderer/Core/Surface.h
View File

@@ -1,34 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Surface.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 18:57:55 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:58:15 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_SURFACE__
#define __MLX_VK_SURFACE__
namespace mlx
{
class Surface
{
public:
void Create(class Renderer& renderer);
void Destroy() noexcept;
VkSurfaceFormatKHR ChooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& available_formats);
inline VkSurfaceKHR& operator()() noexcept { return m_surface; }
inline VkSurfaceKHR& Get() noexcept { return m_surface; }
private:
VkSurfaceKHR m_surface = VK_NULL_HANDLE;
};
}
#endif // __MLX_VK_SURFACE__

44
runtime/Includes/Renderer/Core/ValidationLayers.h
View File

@@ -1,44 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ValidationLayers.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/19 14:04:25 by maldavid #+# #+# */
/* Updated: 2024/04/23 19:16:25 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __VK_VALIDATION_LAYERS__
#define __VK_VALIDATION_LAYERS__
namespace mlx
{
class ValidationLayers
{
public:
ValidationLayers() = default;
void Init();
void Destroy();
bool CheckValidationLayerSupport();
void PopulateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& create_info);
VkResult SetDebugUtilsObjectNameEXT(VkObjectType object_type, std::uint64_t object_handle, const char* object_name);
~ValidationLayers() = default;
private:
VkResult CreateDebugUtilsMessengerEXT(const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator);
static VKAPI_ATTR VkBool32 VKAPI_CALL DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT message_severity, VkDebugUtilsMessageTypeFlagsEXT message_type, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData);
void DestroyDebugUtilsMessengerEXT(const VkAllocationCallbacks* pAllocator);
private:
VkDebugUtilsMessengerEXT m_debug_messenger;
PFN_vkSetDebugUtilsObjectNameEXT f_vkSetDebugUtilsObjectNameEXT = nullptr;
};
}
#endif

48
runtime/Includes/Renderer/Descriptor.h git.filemode.normal_file
View File

@@ -0,0 +1,48 @@
#ifndef __MLX_DESCRIPTOR_SET__
#define __MLX_DESCRIPTOR_SET__
#include <Renderer/Enums.h>
#include <Renderer/RenderCore.h>
#include <Renderer/Pipelines/Shader.h>
#include <Renderer/Vulkan/VulkanPrototypes.h>
namespace mlx
{
struct Descriptor
{
NonOwningPtr<class GPUBuffer> storage_buffer_ptr;
NonOwningPtr<class GPUBuffer> uniform_buffer_ptr;
NonOwningPtr<class Image> image_ptr;
VkDescriptorType type;
ShaderType shader_type;
std::uint32_t binding;
};
class DescriptorSet
{
public:
DescriptorSet() { m_set.fill(VK_NULL_HANDLE); }
DescriptorSet(const ShaderSetLayout& layout, VkDescriptorSetLayout vklayout, ShaderType shader_type);
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;
[[nodiscard]] inline VkDescriptorSet GetSet(std::size_t i) const noexcept { return m_set[i]; }
[[nodiscard]] inline DescriptorSet Duplicate() const { return DescriptorSet{ m_set_layout, m_descriptors }; }
[[nodiscard]] inline bool IsInit() const noexcept { return m_set[0] != VK_NULL_HANDLE; }
~DescriptorSet() = default;
private:
DescriptorSet(VkDescriptorSetLayout layout, const std::vector<Descriptor>& descriptors);
private:
std::vector<Descriptor> m_descriptors;
std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> m_set;
VkDescriptorSetLayout m_set_layout;
};
}
#endif

42
runtime/Includes/Renderer/Descriptors/DescriptorPool.h
View File

@@ -1,42 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* DescriptorPool.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:32:43 by maldavid #+# #+# */
/* Updated: 2024/04/23 19:36:03 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __VK_DESCRIPTOR_POOL__
#define __VK_DESCRIPTOR_POOL__
namespace mlx
{
class DescriptorPool
{
public:
DescriptorPool() = default;
void Init(std::vector<VkDescriptorPoolSize> sizes);
VkDescriptorSet AllocateDescriptorSet(class DescriptorSetLayout& layout);
void FreeDescriptor(VkDescriptorSet set);
void Destroy() noexcept;
inline VkDescriptorPool& operator()() noexcept { return m_pool; }
inline VkDescriptorPool& Get() noexcept { return m_pool; }
inline std::size_t GetNumberOfSetsAllocated() const noexcept { return m_allocated_sets; }
inline bool IsInit() const noexcept { return m_pool != VK_NULL_HANDLE; }
~DescriptorPool() = default;
private:
VkDescriptorPool m_pool = VK_NULL_HANDLE;
std::size_t m_allocated_sets = 0;
};
}
#endif

35
runtime/Includes/Renderer/Descriptors/DescriptorPoolManager.h
View File

@@ -1,35 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* DescriptorPoolManager.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/20 06:26:26 by maldavid #+# #+# */
/* Updated: 2024/04/23 19:40:22 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_DESCRIPTOR_POOL_MANAGER__
#define __MLX_DESCRIPTOR_POOL_MANAGER__
#include <Renderer/Descriptors/DescriptorPool.h>
namespace mlx
{
class DescriptorPoolManager
{
public:
DescriptorPoolManager() = default;
DescriptorPool& GetAvailablePool();
void DestroyAllPools();
~DescriptorPoolManager() = default;
private:
std::list<DescriptorPool> m_pools;
};
}
#endif

56
runtime/Includes/Renderer/Descriptors/DescriptorSet.h
View File

@@ -1,56 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* DescriptorSet.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:39:36 by maldavid #+# #+# */
/* Updated: 2024/07/05 13:42:22 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __VK_DESCRIPTOR_SET__
#define __VK_DESCRIPTOR_SET__
#include <Renderer/Core/RenderCore.h>
#include <Renderer/Descriptors/DescriptorSetLayout.h>
namespace mlx
{
class DescriptorSet
{
public:
DescriptorSet() = default;
void Init(NonOwningPtr<class Renderer> renderer, NonOwningPtr<class DescriptorPool> pool, DescriptorSetLayout layout);
void WriteDescriptor(int binding, NonOwningPtr<class UniformBuffer> ubo) const noexcept;
void WriteDescriptor(int binding, const class Image& image) const noexcept;
inline bool IsInit() const noexcept { return p_pool && p_renderer; }
void Bind() noexcept;
DescriptorSet Duplicate();
VkDescriptorSet& operator()() noexcept;
VkDescriptorSet& Get() noexcept;
inline const DescriptorSetLayout& GetLayout() const noexcept { return m_layout; }
inline const std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT>& GetAllFramesDescriptorSets() const { return m_desc_set; }
void Destroy() noexcept;
~DescriptorSet() = default;
private:
DescriptorSetLayout m_layout;
std::array<VkDescriptorSet, MAX_FRAMES_IN_FLIGHT> m_desc_set;
NonOwningPtr<class DescriptorPool> p_pool;
NonOwningPtr<class Renderer> p_renderer;
};
}
#endif

38
runtime/Includes/Renderer/Descriptors/DescriptorSetLayout.h
View File

@@ -1,38 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* DescriptorSetLayout.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/23 18:36:22 by maldavid #+# #+# */
/* Updated: 2024/04/23 22:15:01 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __VK_DESCRIPTOR_SET_LAYOUT__
#define __VK_DESCRIPTOR_SET_LAYOUT__
namespace mlx
{
class DescriptorSetLayout
{
public:
DescriptorSetLayout() = default;
void Init(std::vector<std::pair<int, VkDescriptorType>> binds, VkShaderStageFlagBits stage);
void Destroy() noexcept;
inline VkDescriptorSetLayout operator()() const noexcept { return m_layout; }
inline VkDescriptorSetLayout Get() const noexcept { return m_layout; }
inline const std::vector<std::pair<int, VkDescriptorType>>& GetBindings() const noexcept { return m_bindings; }
~DescriptorSetLayout() = default;
private:
std::vector<std::pair<int, VkDescriptorType>> m_bindings;
VkDescriptorSetLayout m_layout = VK_NULL_HANDLE;
};
}
#endif

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

@@ -1,15 +1,3 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Enums.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/27 22:02:58 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:39:31 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_RENDERER_ENUMS__
#define __MLX_RENDERER_ENUMS__
@@ -18,6 +6,7 @@ namespace mlx
enum class BufferType
{
Constant = 0,
Staging,
HighDynamic, // typically stored in RAM
LowDynamic, // typically stored in VRAM
@@ -25,35 +14,13 @@ namespace mlx
};
constexpr std::size_t BufferTypeCount = static_cast<std::size_t>(BufferType::EndEnum);
enum class CommandResourceState
enum class ImageType
{
Held = 0,
Free,
Color = 0,
EndEnum
};
constexpr std::size_t CommandResourceStateCount = static_cast<std::size_t>(CommandResourceState::EndEnum);
enum class CommandBufferState
{
Uninit = 0, // buffer not initialized or destroyed
Ready, // buffer ready to be used after having been submitted
Idle, // buffer has recorded informations but has not been submitted
Recording, // buffer is currently recording
Submitted, // buffer has been submitted
EndEnum
};
constexpr std::size_t CommandBufferStateCount = static_cast<std::size_t>(CommandBufferState::EndEnum);
enum class CommandBufferType
{
SingleTime = 0,
LongTime,
EndEnum
};
constexpr std::size_t CommandBufferTypeCount = static_cast<std::size_t>(CommandBufferType::EndEnum);
constexpr std::size_t ImageTypeCount = static_cast<std::size_t>(ImageType::EndEnum);
}
#endif

102
runtime/Includes/Renderer/Image.h git.filemode.normal_file
View File

@@ -0,0 +1,102 @@
#ifndef __MLX_IMAGE__
#define __MLX_IMAGE__
#include <Maths/Vec4.h>
#include <Renderer/RenderCore.h>
#include <Renderer/Buffer.h>
#include <Utils/Buffer.h>
#include <Renderer/Enums.h>
namespace mlx
{
class Image
{
public:
Image() = default;
inline void Init(VkImage image, VkFormat format, std::uint32_t width, std::uint32_t height, VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED) noexcept
{
m_image = image;
m_format = format;
m_width = width;
m_height = height;
m_layout = layout;
}
void Init(ImageType type, std::uint32_t width, std::uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, bool is_multisampled = false);
void CreateImageView(VkImageViewType type, VkImageAspectFlags aspectFlags, int layer_count = 1) noexcept;
void CreateSampler() noexcept;
void TransitionLayout(VkImageLayout new_layout, VkCommandBuffer cmd = VK_NULL_HANDLE);
void Clear(VkCommandBuffer cmd, Vec4f color);
void DestroySampler() noexcept;
void DestroyImageView() noexcept;
virtual void Destroy() noexcept;
[[nodiscard]] MLX_FORCEINLINE VkImage Get() const noexcept { return m_image; }
[[nodiscard]] MLX_FORCEINLINE VkImage operator()() const noexcept { return m_image; }
[[nodiscard]] MLX_FORCEINLINE VkDeviceMemory GetDeviceMemory() const noexcept { return m_memory.memory; }
[[nodiscard]] MLX_FORCEINLINE VkImageView GetImageView() const noexcept { return m_image_view; }
[[nodiscard]] MLX_FORCEINLINE VkFormat GetFormat() const noexcept { return m_format; }
[[nodiscard]] MLX_FORCEINLINE VkImageTiling GetTiling() const noexcept { return m_tiling; }
[[nodiscard]] MLX_FORCEINLINE VkImageLayout GetLayout() const noexcept { return m_layout; }
[[nodiscard]] MLX_FORCEINLINE VkSampler GetSampler() const noexcept { return m_sampler; }
[[nodiscard]] MLX_FORCEINLINE std::uint32_t GetWidth() const noexcept { return m_width; }
[[nodiscard]] MLX_FORCEINLINE std::uint32_t GetHeight() const noexcept { return m_height; }
[[nodiscard]] MLX_FORCEINLINE bool IsInit() const noexcept { return m_image != VK_NULL_HANDLE; }
[[nodiscard]] MLX_FORCEINLINE ImageType GetType() const noexcept { return m_type; }
virtual ~Image() = default;
private:
VmaAllocation m_allocation;
VkImage m_image = VK_NULL_HANDLE;
VkImageView m_image_view = VK_NULL_HANDLE;
VkSampler m_sampler = VK_NULL_HANDLE;
VkFormat m_format;
VkImageTiling m_tiling;
VkImageLayout m_layout = VK_IMAGE_LAYOUT_UNDEFINED;
ImageType m_type;
std::uint32_t m_width = 0;
std::uint32_t m_height = 0;
bool m_is_multisampled = false;
};
class Texture : public Image
{
public:
Texture() = default;
Texture(CPUBuffer pixels, std::uint32_t width, std::uint32_t height, VkFormat format = VK_FORMAT_R8G8B8A8_SRGB, bool is_multisampled = false)
{
Init(std::move(pixels), width, height, format, is_multisampled);
}
inline void Init(CPUBuffer pixels, std::uint32_t width, std::uint32_t height, VkFormat format = VK_FORMAT_R8G8B8A8_SRGB, bool is_multisampled = false)
{
Image::Init(ImageType::Color, width, height, format, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, is_multisampled);
Image::CreateImageView(VK_IMAGE_VIEW_TYPE_2D, VK_IMAGE_ASPECT_COLOR_BIT);
Image::CreateSampler();
if(pixels)
{
TransitionLayout(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
GPUBuffer staging_buffer;
std::size_t size = width * height * kvfFormatSize(format);
staging_buffer.Init(BufferType::Staging, size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, pixels);
VkCommandBuffer cmd = kvfCreateCommandBuffer(RenderCore::Get().GetDevice());
kvfBeginCommandBuffer(cmd, VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT);
kvfCopyBufferToImage(cmd, Image::Get(), staging_buffer.Get(), staging_buffer.GetOffset(), VK_IMAGE_ASPECT_COLOR_BIT, { width, height, 1 });
vkEndCommandBuffer(cmd);
VkFence fence = kvfCreateFence(RenderCore::Get().GetDevice());
kvfSubmitSingleTimeCommandBuffer(RenderCore::Get().GetDevice(), cmd, KVF_GRAPHICS_QUEUE, fence);
kvfDestroyFence(RenderCore::Get().GetDevice(), fence);
staging_buffer.Destroy();
}
if(!pixels)
TransitionLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
else
TransitionLayout(VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
}
~Texture() override { Destroy(); }
};
}
#endif

84
runtime/Includes/Renderer/Images/Image.h
View File

@@ -1,84 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Image.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/25 11:54:21 by maldavid #+# #+# */
/* Updated: 2024/07/05 13:40:51 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_IMAGE__
#define __MLX_VK_IMAGE__
#include <Renderer/Command/CommandResource.h>
#include <Renderer/Command/CommandBuffer.h>
#include <Renderer/Command/CommandPool.h>
namespace mlx
{
std::uint32_t FormatSize(VkFormat format);
bool IsStencilFormat(VkFormat format);
bool IsDepthFormat(VkFormat format);
VkFormat BitsToFormat(std::uint32_t bits);
VkPipelineStageFlags LayoutToAccessMask(VkImageLayout layout, bool is_destination);
class Image : public CommandResource
{
friend class Swapchain;
public:
Image() = default;
inline void Create(VkImage image, VkFormat format, std::uint32_t width, std::uint32_t height, VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED) noexcept
{
m_image = image;
m_format = format;
m_width = width;
m_height = height;
m_layout = layout;
}
void Create(std::uint32_t width, std::uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, const char* name, bool decated_memory = false);
void CreateImageView(VkImageViewType type, VkImageAspectFlags aspect_flags) noexcept;
void CreateSampler() noexcept;
void CopyFromBuffer(class Buffer& buffer);
void CopyToBuffer(class Buffer& buffer);
void TransitionLayout(VkImageLayout new_layout, NonOwningPtr<CommandBuffer> cmd = nullptr);
virtual void Destroy() noexcept;
inline VkImage Get() noexcept { return m_image; }
inline VkImage operator()() noexcept { return m_image; }
inline VkImageView GetImageView() const noexcept { return m_image_view; }
inline VkFormat GetFormat() const noexcept { return m_format; }
inline VkImageTiling GetTiling() const noexcept { return m_tiling; }
inline VkImageLayout GetLayout() const noexcept { return m_layout; }
inline VkSampler GetSampler() const noexcept { return m_sampler; }
inline std::uint32_t GetWidth() const noexcept { return m_width; }
inline std::uint32_t GetHeight() const noexcept { return m_height; }
inline bool IsInit() const noexcept { return m_image != VK_NULL_HANDLE; }
virtual ~Image() = default;
private:
void DestroySampler() noexcept;
void DestroyImageView() noexcept;
private:
VmaAllocation m_allocation;
VkImage m_image = VK_NULL_HANDLE;
VkImageView m_image_view = VK_NULL_HANDLE;
VkSampler m_sampler = VK_NULL_HANDLE;
#ifdef DEBUG
std::string m_name;
#endif
VkFormat m_format;
VkImageTiling m_tiling;
VkImageLayout m_layout = VK_IMAGE_LAYOUT_UNDEFINED;
std::uint32_t m_width = 0;
std::uint32_t m_height = 0;
};
}
#endif

63
runtime/Includes/Renderer/Images/Texture.h
View File

@@ -1,63 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Texture.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/08 02:24:58 by maldavid #+# #+# */
/* Updated: 2024/07/05 13:42:41 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_TEXTURE__
#define __MLX_TEXTURE__
#include <Renderer/Images/Image.h>
#include <Renderer/Descriptors/DescriptorSet.h>
#include <Renderer/Buffers/IndexBuffer.h>
#include <Renderer/Buffers/VertexBuffer.h>
namespace mlx
{
class Texture : public Image
{
public:
Texture() = default;
void Create(std::uint8_t* pixels, std::uint32_t width, std::uint32_t height, VkFormat format, const char* name, bool dedicated_memory = false);
void Render(class Renderer& renderer, int x, int y);
void Destroy() noexcept override;
void SetPixel(int x, int y, std::uint32_t color) noexcept;
int GetPixel(int x, int y) noexcept;
inline void SetDescriptor(DescriptorSet&& set) noexcept { m_set = set; }
inline VkDescriptorSet GetSet() noexcept { return m_set.IsInit() ? m_set.Get() : VK_NULL_HANDLE; }
inline void UpdateSet(int binding) noexcept { m_set.WriteDescriptor(binding, *this); m_has_set_been_updated = true; }
inline bool HasBeenUpdated() const noexcept { return m_has_set_been_updated; }
inline constexpr void ResetUpdate() noexcept { m_has_set_been_updated = false; }
~Texture() = default;
private:
void OpenCPUmap();
private:
ConstantVertexBuffer m_vbo;
ConstantIndexBuffer m_ibo;
#ifdef DEBUG
std::string m_name;
#endif
DescriptorSet m_set;
std::vector<std::uint32_t> m_cpu_map;
std::optional<Buffer> m_buf_map = std::nullopt;
void* m_map = nullptr;
bool m_has_been_modified = false;
bool m_has_set_been_updated = false;
};
Texture* StbTextureLoad(std::filesystem::path file, int* w, int* h);
}
#endif

43
runtime/Includes/Renderer/Images/TextureAtlas.h
View File

@@ -1,43 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* TextureAtlas.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/07 16:36:33 by maldavid #+# #+# */
/* Updated: 2024/07/05 13:52:40 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_TEXTURE_ATLAS__
#define __MLX_TEXTURE_ATLAS__
#include <Renderer/Images/Texture.h>
namespace mlx
{
class TextureAtlas : public Image
{
public:
TextureAtlas() = default;
void Create(std::uint8_t* pixels, std::uint32_t width, std::uint32_t height, VkFormat format, const char* name, bool dedicated_memory = false);
void Render(class Renderer& renderer, int x, int y, std::uint32_t ibo_size) const;
void Destroy() noexcept override;
inline void SetDescriptor(DescriptorSet&& set) noexcept { m_set = set; }
inline DescriptorSet GetSet() noexcept { return m_set; }
inline void UpdateSet(int binding) noexcept { m_set.WriteDescriptor(binding, *this); m_has_been_updated = true; }
inline bool HasBeenUpdated() const noexcept { return m_has_been_updated; }
inline constexpr void ResetUpdate() noexcept { m_has_been_updated = false; }
~TextureAtlas() = default;
private:
DescriptorSet m_set;
bool m_has_been_updated = false;
};
}
#endif

59
runtime/Includes/Renderer/Images/TextureDescriptor.h
View File

@@ -1,59 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* TextureDescriptor.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/11 01:00:13 by maldavid #+# #+# */
/* Updated: 2024/04/23 22:08:02 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_TEXTURE_DESCRIPTOR__
#define __MLX_TEXTURE_DESCRIPTOR__
#include <Renderer/Images/Texture.h>
#include <Renderer/Core/DrawableResource.h>
#include <Utils/CombineHash.h>
namespace mlx
{
struct TextureRenderDescriptor : public DrawableResource
{
NonOwningPtr<Texture> texture;
int x;
int y;
TextureRenderDescriptor(NonOwningPtr<Texture> _texture, int _x, int _y) : texture(_texture), x(_x), y(_y) {}
inline bool operator==(const TextureRenderDescriptor& rhs) const { return texture == rhs.texture && x == rhs.x && y == rhs.y; }
inline void Render(class Renderer& renderer) override
{
if(!texture->IsInit())
return;
texture->Render(renderer, x, y);
}
inline void ResetUpdate() override
{
if(!texture->IsInit())
return;
texture->ResetUpdate();
}
};
}
namespace std
{
template <>
struct hash<mlx::TextureRenderDescriptor>
{
std::size_t operator()(const mlx::TextureRenderDescriptor& d) const noexcept
{
std::size_t hash = 0;
mlx::HashCombine(hash, d.texture, d.x, d.y);
return hash;
}
};
}
#endif

39
runtime/Includes/Renderer/Images/TextureRegistry.h
View File

@@ -1,39 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* TextureRegistry.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/11 00:56:15 by maldavid #+# #+# */
/* Updated: 2024/07/05 13:43:48 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_TEXTURE_MANAGER__
#define __MLX_TEXTURE_MANAGER__
#include <Renderer/Images/TextureDescriptor.h>
namespace mlx
{
class TextureRegistry
{
public:
TextureRegistry() = default;
inline void Clear();
inline std::pair<NonOwningPtr<DrawableResource>, bool> RegisterTexture(NonOwningPtr<Texture> texture, int x, int y);
inline bool IsTextureKnown(NonOwningPtr<Texture> texture) noexcept;
inline void EraseTextures(NonOwningPtr<Texture> texture);
~TextureRegistry() = default;
private:
std::unordered_set<TextureRenderDescriptor> m_texture_descriptors;
};
}
#include <Renderer/Images/TextureRegistry.inl>
#endif

52
runtime/Includes/Renderer/Images/TextureRegistry.inl
View File

@@ -1,52 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* TextureRegistry.inl :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/23 22:08:46 by maldavid #+# #+# */
/* Updated: 2024/04/23 22:11:09 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#pragma once
#include <Renderer/Images/TextureRegistry.h>
namespace mlx
{
void TextureRegistry::Clear()
{
m_texture_descriptors.clear();
}
std::pair<NonOwningPtr<DrawableResource>, bool> TextureRegistry::RegisterTexture(NonOwningPtr<Texture> texture, int x, int y)
{
MLX_PROFILE_FUNCTION();
auto res = m_texture_descriptors.emplace(texture, x, y);
return std::make_pair(static_cast<DrawableResource*>(&const_cast<TextureRenderDescriptor&>(*res.first)), res.second);
}
bool TextureRegistry::IsTextureKnown(NonOwningPtr<Texture> texture) noexcept
{
MLX_PROFILE_FUNCTION();
for(const auto& desc : m_texture_descriptors)
{
if(desc.texture == texture)
return true;
}
return false;
}
void TextureRegistry::EraseTextures(NonOwningPtr<Texture> texture)
{
MLX_PROFILE_FUNCTION();
for(auto it = m_texture_descriptors.begin(); it != m_texture_descriptors.end();)
{
if(it->texture == texture)
it = m_texture_descriptors.erase(it);
else
++it;
}
}
}

18
runtime/Includes/Renderer/Core/Memory.h → runtime/Includes/Renderer/Memory.h
View File

@@ -1,24 +1,12 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Memory.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/10/20 02:13:03 by maldavid #+# #+# */
/* Updated: 2024/03/27 22:49:57 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_MEMORY__
#define __MLX_VK_MEMORY__
namespace mlx
{
class GPUallocator
class GPUAllocator
{
public:
GPUallocator() = default;
GPUAllocator() = default;
void Init() noexcept;
void Destroy() noexcept;
@@ -36,7 +24,7 @@ namespace mlx
void Flush(VmaAllocation allocation, VkDeviceSize size, VkDeviceSize offset) noexcept;
~GPUallocator() = default;
~GPUAllocator() = default;
private:
VmaAllocator m_allocator;

57
runtime/Includes/Renderer/Pipelines/Graphics.h git.filemode.normal_file
View File

@@ -0,0 +1,57 @@
#ifndef __MLX_GRAPHICS_PIPELINE__
#define __MLX_GRAPHICS_PIPELINE__
#include <Renderer/Image.h>
#include <Utils/NonOwningPtr.h>
#include <Renderer/Pipelines/Shader.h>
#include <Renderer/Pipelines/Pipeline.h>
namespace mlx
{
struct GraphicPipelineDescriptor
{
std::shared_ptr<Shader> vertex_shader;
std::shared_ptr<Shader> fragment_shader;
std::vector<NonOwningPtr<Texture>> color_attachments;
NonOwningPtr<class Renderer> renderer = nullptr;
bool clear_color_attachments = true;
bool no_vertex_inputs = false;
};
class GraphicPipeline : public Pipeline
{
public:
GraphicPipeline() = default;
void Init(const GraphicPipelineDescriptor& descriptor);
bool BindPipeline(VkCommandBuffer command_buffer, std::size_t framebuffer_index, std::array<float, 4> clear) noexcept;
void EndPipeline(VkCommandBuffer command_buffer) noexcept override;
void Destroy() noexcept;
[[nodiscard]] inline VkPipeline GetPipeline() const override { return m_pipeline; }
[[nodiscard]] inline VkPipelineLayout GetPipelineLayout() const override { return m_pipeline_layout; }
[[nodiscard]] inline VkPipelineBindPoint GetPipelineBindPoint() const override { return VK_PIPELINE_BIND_POINT_GRAPHICS; }
~GraphicPipeline() = default;
private:
void CreateFramebuffers(const std::vector<NonOwningPtr<Texture>>& render_targets, bool clear_attachments);
void TransitionAttachments(VkCommandBuffer cmd = VK_NULL_HANDLE);
// Private override to remove access
bool BindPipeline(VkCommandBuffer) noexcept override { return false; };
private:
std::vector<NonOwningPtr<Texture>> m_attachments;
std::vector<VkFramebuffer> m_framebuffers;
std::vector<VkClearValue> m_clears;
std::shared_ptr<Shader> p_vertex_shader;
std::shared_ptr<Shader> p_fragment_shader;
VkRenderPass m_renderpass = VK_NULL_HANDLE;
VkPipeline m_pipeline = VK_NULL_HANDLE;
VkPipelineLayout m_pipeline_layout = VK_NULL_HANDLE;
NonOwningPtr<class Renderer> p_renderer;
};
}
#endif

35
runtime/Includes/Renderer/Pipelines/Pipeline.h
View File

@@ -1,36 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Pipeline.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/18 21:23:52 by maldavid #+# #+# */
/* Updated: 2024/03/28 22:15:38 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_PIPELINE__
#define __MLX_PIPELINE__
#ifndef __PIPELINE__
#define __PIPELINE__
#include <Renderer/Command/CommandBuffer.h>
#include <Renderer/Vulkan/VulkanPrototypes.h>
namespace mlx
{
class GraphicPipeline
class Pipeline
{
public:
void init(class Renderer& renderer);
void Destroy() noexcept;
Pipeline() = default;
inline void BindPipeline(CommandBuffer& command_buffer) noexcept { vkCmdBindPipeline(command_buffer.Get(), VK_PIPELINE_BIND_POINT_GRAPHICS, m_graphics_pipeline); }
inline virtual bool BindPipeline(VkCommandBuffer command_buffer) noexcept { vkCmdBindPipeline(command_buffer, GetPipelineBindPoint(), GetPipeline()); return true; }
inline virtual void EndPipeline([[maybe_unused]] VkCommandBuffer command_buffer) noexcept {}
inline const VkPipeline& GetPipeline() const noexcept { return m_graphics_pipeline; }
inline const VkPipelineLayout& GetPipelineLayout() const noexcept { return m_pipeline_layout; }
virtual VkPipeline GetPipeline() const = 0;
virtual VkPipelineLayout GetPipelineLayout() const = 0;
virtual VkPipelineBindPoint GetPipelineBindPoint() const = 0;
private:
VkPipeline m_graphics_pipeline = VK_NULL_HANDLE;
VkPipelineLayout m_pipeline_layout = VK_NULL_HANDLE;
virtual ~Pipeline() = default;
};
}

68
runtime/Includes/Renderer/Pipelines/Shader.h git.filemode.normal_file
View File

@@ -0,0 +1,68 @@
#ifndef __MLX_SHADER__
#define __MLX_SHADER__
namespace mlx
{
struct ShaderSetLayout
{
std::vector<std::pair<int, VkDescriptorType> > binds;
ShaderSetLayout(std::vector<std::pair<int, VkDescriptorType> > b) : binds(std::move(b)) {}
};
struct ShaderPushConstantLayout
{
std::size_t offset;
std::size_t size;
ShaderPushConstantLayout(std::size_t o, std::size_t s) : offset(o), size(s) {}
};
struct ShaderLayout
{
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;
std::vector<VkDescriptorSetLayout> set_layouts;
};
class Shader
{
public:
Shader(const std::vector<std::uint8_t>& bytecode, ShaderType type, ShaderLayout layout);
[[nodiscard]] inline const ShaderLayout& GetShaderLayout() const { return m_layout; }
[[nodiscard]] inline const std::vector<std::uint8_t>& GetByteCode() const noexcept { return m_bytecode; }
[[nodiscard]] inline const ShaderPipelineLayoutPart& GetPipelineLayout() const noexcept { return m_pipeline_layout_part; }
[[nodiscard]] inline VkShaderModule GetShaderModule() const noexcept { return m_module; }
[[nodiscard]] inline VkShaderStageFlagBits GetShaderStage() const noexcept { return m_stage; }
~Shader();
private:
void GeneratePipelineLayout(ShaderLayout layout);
private:
ShaderLayout m_layout;
ShaderPipelineLayoutPart m_pipeline_layout_part;
std::vector<std::uint8_t> m_bytecode;
std::vector<VkDescriptorSetLayout> m_set_layouts;
VkShaderStageFlagBits m_stage;
VkShaderModule m_module = VK_NULL_HANDLE;
};
}
#endif

48
runtime/Includes/Renderer/PixelPut.h
View File

@@ -1,48 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* PixelPut.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/03/31 13:18:50 by maldavid #+# #+# */
/* Updated: 2024/04/24 01:46:11 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_PIXEL_PUT__
#define __MLX_PIXEL_PUT__
#include <Renderer/Images/Texture.h>
#include <Renderer/Descriptors/DescriptorSet.h>
namespace mlx
{
class PixelPutPipeline
{
public:
PixelPutPipeline() = default;
void Init(std::uint32_t width, std::uint32_t height, class Renderer& renderer) noexcept;
void SetPixel(int x, int y, std::uint32_t color) noexcept;
void Render(class Renderer& renderer) noexcept;
void Clear();
void Destroy() noexcept;
~PixelPutPipeline() = default;
private:
Texture m_texture;
Buffer m_buffer;
// using vector as CPU map and not directly writting to mapped buffer to improve performances
std::vector<std::uint32_t> m_cpu_map;
void* m_buffer_map = nullptr;
std::uint32_t m_width = 0;
std::uint32_t m_height = 0;
bool m_has_been_modified = true;
};
}
#endif

39
runtime/Includes/Renderer/RenderCore.h git.filemode.normal_file
View File

@@ -0,0 +1,39 @@
#ifndef __MLX_RENDER_CORE__
#define __MLX_RENDER_CORE__
#include <Renderer/Memory.h>
namespace mlx
{
constexpr const int MAX_FRAMES_IN_FLIGHT = 3;
class RenderCore : public Singleton<RenderCore>
{
friend class Singleton<RenderCore>;
public:
void Init() noexcept;
void Destroy() noexcept;
[[nodiscard]] MLX_FORCEINLINE VkInstance GetInstance() const noexcept { return m_instance; }
[[nodiscard]] MLX_FORCEINLINE VkInstance& GetInstanceRef() noexcept { return m_instance; }
[[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; }
inline void WaitDeviceIdle() const noexcept { vkDeviceWaitIdle(m_device); }
private:
RenderCore() = default;
~RenderCore() = default;
private:
GPUAllocator m_allocator;
VkInstance m_instance = VK_NULL_HANDLE;
VkDevice m_device = VK_NULL_HANDLE;
VkPhysicalDevice m_physical_device = VK_NULL_HANDLE;
};
}
#endif

29
runtime/Includes/Renderer/RenderPasses/2DPass.h git.filemode.normal_file
View File

@@ -0,0 +1,29 @@
#ifndef __MLX_2D_PASS__
#define __MLX_2D_PASS__
#include <Renderer/Descriptor.h>
#include <Renderer/Pipelines/Shader.h>
#include <Renderer/Pipelines/Graphics.h>
namespace mlx
{
class Render2DPass
{
public:
Render2DPass() = default;
void Init();
void Pass(class Scene& scene, class Renderer& renderer, class Texture& render_target);
void Destroy();
~Render2DPass() = default;
private:
GraphicPipeline m_pipeline;
std::shared_ptr<DescriptorSet> p_viewer_data_set;
std::shared_ptr<UniformBuffer> p_viewer_data_buffer;
std::shared_ptr<DescriptorSet> p_texture_set;
std::shared_ptr<Shader> p_vertex_shader;
std::shared_ptr<Shader> p_fragment_shader;
};
}
#endif

27
runtime/Includes/Renderer/RenderPasses/FinalPass.h git.filemode.normal_file
View File

@@ -0,0 +1,27 @@
#ifndef __MLX_FINAL_PASS__
#define __MLX_FINAL_PASS__
#include <Renderer/Descriptor.h>
#include <Renderer/Pipelines/Shader.h>
#include <Renderer/Pipelines/Graphics.h>
namespace mlx
{
class FinalPass
{
public:
FinalPass() = default;
void Init();
void Pass(class Scene& scene, class Renderer& renderer, class Texture& render_target);
void Destroy();
~FinalPass() = default;
private:
GraphicPipeline m_pipeline;
std::shared_ptr<DescriptorSet> p_set;
std::shared_ptr<Shader> p_vertex_shader;
std::shared_ptr<Shader> p_fragment_shader;
};
}
#endif

26
runtime/Includes/Renderer/RenderPasses/Passes.h git.filemode.normal_file
View File

@@ -0,0 +1,26 @@
#ifndef __MLX_PASSES__
#define __MLX_PASSES__
#include <Renderer/Image.h>
#include <Renderer/RenderPasses/FinalPass.h>
#include <Renderer/RenderPasses/2DPass.h>
namespace mlx
{
class RenderPasses
{
public:
RenderPasses() = default;
void Init();
void Pass(class Scene& scene, class Renderer& renderer);
void Destroy();
~RenderPasses() = default;
private:
Render2DPass m_2Dpass;
FinalPass m_final;
Texture m_main_render_texture;
};
}
#endif

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

@@ -1,31 +1,11 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Renderer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/18 17:14:45 by maldavid #+# #+# */
/* Updated: 2024/07/05 13:40:20 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_RENDERER__
#define __MLX_RENDERER__
#ifndef __RENDERER__
#define __RENDERER__
#include <Renderer/Vertex.h>
#include <Renderer/Buffers/UniformBuffer.h>
#include <Renderer/Core/Surface.h>
#include <Renderer/Core/RenderCore.h>
#include <Renderer/Core/Semaphore.h>
#include <Renderer/Pipelines/Pipeline.h>
#include <Renderer/Command/CommandManager.h>
#include <Renderer/Renderpass/Swapchain.h>
#include <Renderer/Renderpass/RenderPass.h>
#include <Renderer/Renderpass/FrameBuffer.h>
#include <Renderer/Descriptors/DescriptorSet.h>
#include <Renderer/Descriptors/DescriptorPool.h>
#include <Renderer/Descriptors/DescriptorSetLayout.h>
#include <Platform/Window.h>
#include <Utils/NonOwningPtr.h>
#include <Renderer/RenderCore.h>
#include <Renderer/Image.h>
#include <Core/EventBus.h>
namespace mlx
{
@@ -34,57 +14,48 @@ namespace mlx
public:
Renderer() = default;
void Init(NonOwningPtr<class Texture> render_target);
void Init(NonOwningPtr<Window> window);
bool BeginFrame();
void EndFrame();
void Destroy();
[[nodiscard]] inline VkSwapchainKHR GetSwapchain() const noexcept { return m_swapchain; }
[[nodiscard]] inline VkSurfaceKHR GetSurface() const noexcept { return m_surface; }
[[nodiscard]] inline VkSemaphore GetImageAvailableSemaphore(int index) const noexcept { return m_image_available_semaphores[index]; }
[[nodiscard]] inline VkSemaphore GetRenderFinishedSemaphore(int index) const noexcept { return m_render_finished_semaphores[index]; }
[[nodiscard]] inline VkCommandBuffer GetCommandBuffer(int index) const noexcept { return m_cmd_buffers[index]; }
[[nodiscard]] inline VkCommandBuffer GetActiveCommandBuffer() const noexcept { return m_cmd_buffers[m_current_frame_index]; }
[[nodiscard]] inline const std::vector<Image>& GetSwapchainImages() const { return m_swapchain_images; }
[[nodiscard]] inline std::size_t& GetDrawCallsCounterRef() noexcept { return m_drawcalls; }
[[nodiscard]] inline std::size_t& GetPolygonDrawnCounterRef() noexcept { return m_polygons_drawn; }
[[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 m_window_ptr; }
inline NonOwningPtr<class Window> GetWindow() { return m_window; }
inline void SetWindow(NonOwningPtr<class Window> window) { m_window = window; }
MLX_FORCEINLINE constexpr void RequireFramebufferResize() noexcept { m_framebuffers_resize = true; }
inline Surface& GetSurface() noexcept { return m_surface; }
inline NonOwningPtr<UniformBuffer> GetUniformBuffer() noexcept { return m_uniform_buffer.get(); }
inline SwapChain& GetSwapChain() noexcept { return m_swapchain; }
inline RenderPass& GetRenderPass() noexcept { return m_pass; }
inline GraphicPipeline& GetPipeline() noexcept { return m_pipeline; }
inline CommandBuffer& GetCmdBuffer(int i) noexcept { return m_cmd.GetCmdBuffer(i); }
inline CommandBuffer& GetActiveCmdBuffer() noexcept { return m_cmd.GetCmdBuffer(m_current_frame_index); }
inline FrameBuffer& GetFrameBuffer(int i) noexcept { return m_framebuffers[i]; }
inline DescriptorSet& GetVertDescriptorSet() noexcept { return m_vert_set; }
inline DescriptorSet& GetFragDescriptorSet() noexcept { return m_frag_set; }
inline std::uint32_t GetActiveImageIndex() noexcept { return m_current_frame_index; }
inline std::uint32_t GetImageIndex() noexcept { return m_image_index; }
constexpr inline void RequireFrameBufferResize() noexcept { m_framebuffer_resized = true; }
void Destroy() noexcept;
~Renderer() = default;
private:
void RecreateRenderData();
void CreateSwapchain();
void DestroySwapchain();
private:
GraphicPipeline m_pipeline;
CommandManager m_cmd;
RenderPass m_pass;
Surface m_surface;
SwapChain m_swapchain;
std::array<Semaphore, MAX_FRAMES_IN_FLIGHT> m_render_finished_semaphores;
std::array<Semaphore, MAX_FRAMES_IN_FLIGHT> m_image_available_semaphores;
std::vector<FrameBuffer> m_framebuffers;
DescriptorSet m_vert_set;
DescriptorSet m_frag_set;
std::unique_ptr<UniformBuffer> m_uniform_buffer;
NonOwningPtr<class Window> m_window;
NonOwningPtr<class Texture> m_render_target;
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;
std::array<VkFence, MAX_FRAMES_IN_FLIGHT> m_cmd_fences;
std::vector<Image> m_swapchain_images;
NonOwningPtr<Window> p_window;
VkSurfaceKHR m_surface = VK_NULL_HANDLE;
VkSwapchainKHR m_swapchain = VK_NULL_HANDLE;
std::uint32_t m_current_frame_index = 0;
std::uint32_t m_image_index = 0;
bool m_framebuffer_resized = false;
std::uint32_t m_swapchain_image_index = 0;
std::size_t m_drawcalls = 0;
std::size_t m_polygons_drawn = 0;
bool m_framebuffers_resize = false;
};
}

36
runtime/Includes/Renderer/Renderpass/FrameBuffer.h
View File

@@ -1,36 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* FrameBuffer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:19:44 by maldavid #+# #+# */
/* Updated: 2024/03/28 22:16:02 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_FRAMEBUFFER__
#define __MLX_VK_FRAMEBUFFER__
namespace mlx
{
class FrameBuffer
{
public:
void Init(class RenderPass& renderpass, class Image& image);
void Destroy() noexcept;
inline VkFramebuffer& operator()() noexcept { return m_framebuffer; }
inline VkFramebuffer& Get() noexcept { return m_framebuffer; }
inline std::uint32_t GetWidth() const noexcept { return m_width; }
inline std::uint32_t GetHeight() const noexcept { return m_height; }
private:
VkFramebuffer m_framebuffer = VK_NULL_HANDLE;
std::uint32_t m_width = 0;
std::uint32_t m_height = 0;
};
}
#endif // __MLX_VK_FRAMEBUFFER__

36
runtime/Includes/Renderer/Renderpass/RenderPass.h
View File

@@ -1,36 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* RenderPass.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:22:00 by maldavid #+# #+# */
/* Updated: 2024/03/28 22:16:44 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_RENDER_PASS__
#define __MLX_VK_RENDER_PASS__
namespace mlx
{
class RenderPass
{
public:
void Init(VkFormat attachement_format, VkImageLayout layout);
void Destroy() noexcept;
void Begin(class CmommandBuffer& cmd, class FrameBuffer& fb);
void End(class CommandBuffer& cmd);
inline VkRenderPass& operator()() noexcept { return m_render_pass; }
inline VkRenderPass& Get() noexcept { return m_render_pass; }
private:
VkRenderPass m_render_pass = VK_NULL_HANDLE;
bool m_is_running = false;
};
}
#endif // __MLX_VK_RENDER_PASS__

65
runtime/Includes/Renderer/Renderpass/Swapchain.h
View File

@@ -1,65 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Swapchain.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:23:27 by maldavid #+# #+# */
/* Updated: 2024/03/28 22:18:15 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_SWAPCHAIN__
#define __MLX_VK_SWAPCHAIN__
#include <Renderer/Images/Image.h>
namespace mlx
{
class SwapChain
{
friend class GraphicPipeline;
friend class RenderPass;
friend class Renderer;
public:
struct SwapChainSupportDetails
{
VkSurfaceCapabilitiesKHR capabilities;
std::vector<VkSurfaceFormatKHR> formats;
std::vector<VkPresentModeKHR> present_modes;
};
public:
SwapChain() = default;
void Init(NonOwningPtr<class Renderer> renderer);
void Recreate();
void Destroy() noexcept;
SwapChainSupportDetails QuerySwapChainSupport(VkPhysicalDevice device);
VkExtent2D ChooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities);
VkPresentModeKHR ChooseSwapPresentMode([[maybe_unused]] const std::vector<VkPresentModeKHR> &available_present_modes);
inline VkSwapchainKHR Get() noexcept { return m_swapchain; }
inline VkSwapchainKHR operator()() noexcept { return m_swapchain; }
inline std::size_t GetImagesNumber() const noexcept { return m_images.size(); }
inline Image& GetImage(std::size_t i) noexcept { return m_images[i]; }
inline SwapChainSupportDetails GetSupport() noexcept { return m_swapchain_support; }
inline VkExtent2D GetExtent() noexcept { return m_extent; }
inline VkFormat GetImagesFormat() const noexcept { return m_swapchain_image_format; }
~SwapChain() = default;
private:
SwapChainSupportDetails m_swapchain_support;
VkSwapchainKHR m_swapchain;
std::vector<Image> m_images;
VkFormat m_swapchain_image_format;
VkExtent2D m_extent;
NonOwningPtr<class Renderer> m_renderer;
};
}
#endif // __MLX_VK_SWAPCHAIN__

22
runtime/Includes/Renderer/ScenesRenderer.h git.filemode.normal_file
View File

@@ -0,0 +1,22 @@
#ifndef __MLX_SCENES_RENDERER__
#define __MLX_SCENES_RENDERER__
#include <Renderer/RenderPasses/Passes.h>
namespace mlx
{
class SceneRenderer
{
public:
SceneRenderer() = default;
void Init();
void Render(class Scene& scene, class Renderer& renderer); // TODO : add RTT support
void Destroy();
~SceneRenderer() = default;
private:
RenderPasses m_passes;
};
}
#endif

55
runtime/Includes/Renderer/Texts/Font.h
View File

@@ -1,55 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Font.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/12/11 21:17:04 by kbz_8 #+# #+# */
/* Updated: 2024/07/05 13:53:11 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_FONT__
#define __MLX_FONT__
#include <Renderer/Images/TextureAtlas.h>
#include <Utils/CombineHash.h>
namespace mlx
{
class Font
{
friend class FontLibrary;
public:
Font() = delete;
Font(class Renderer& renderer, const std::filesystem::path& path, float scale);
Font(class Renderer& renderer, const std::string& name, const std::vector<std::uint8_t>& ttf_data, float scale);
inline const std::string& GetName() const { return m_name; }
inline float GetScale() const noexcept { return m_scale; }
inline const std::array<stbtt_packedchar, 96>& GetCharData() const { return m_cdata; }
inline const TextureAtlas& GetAtlas() const noexcept { return m_atlas; }
inline bool operator==(const Font& rhs) const { return rhs.m_name == m_name && rhs.m_scale == m_scale; }
inline bool operator!=(const Font& rhs) const { return rhs.m_name != m_name || rhs.m_scale != m_scale; }
void Destroy();
~Font();
private:
void BuildFont();
private:
std::array<stbtt_packedchar, 96> m_cdata;
TextureAtlas m_atlas;
std::variant<std::filesystem::path, std::vector<std::uint8_t>> m_build_data;
std::string m_name;
class Renderer& m_renderer;
float m_scale = 0;
bool m_is_init = false;
};
}
#endif

47
runtime/Includes/Renderer/Texts/FontLibrary.h
View File

@@ -1,47 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* FontLibrary.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/18 09:26:03 by maldavid #+# #+# */
/* Updated: 2024/03/28 22:21:53 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_FONT_LIBRARY__
#define __MLX_FONT_LIBRARY__
#include <Renderer/Texts/Font.h>
#include <Renderer/Core/RenderCore.h>
#include <Utils/Singleton.h>
namespace mlx
{
using FontID = std::uint32_t;
constexpr FontID nullfont = 0;
class FontLibrary : public Singleton<FontLibrary>
{
friend class Singleton<FontLibrary>;
public:
std::shared_ptr<class Font> GetFontData(FontID id);
FontID AddFontToLibrary(std::shared_ptr<Font> font);
void RemoveFontFromLibrary(FontID id);
void ClearLibrary();
private:
FontLibrary() = default;
~FontLibrary() = default;
private:
std::unordered_map<FontID, std::shared_ptr<class Font>> m_cache;
std::vector<FontID> m_invalid_ids;
FontID m_current_id = 1;
};
}
#endif

49
runtime/Includes/Renderer/Texts/Text.h
View File

@@ -1,49 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Text.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/11 00:09:04 by maldavid #+# #+# */
/* Updated: 2024/03/28 22:23:50 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_TEXT__
#define __MLX_TEXT__
#include <Renderer/Texts/Font.h>
#include <Renderer/Texts/FontLibrary.h>
#include <Renderer/Buffers/IndexBuffer.h>
#include <Renderer/Buffers/VertexBuffer.h>
namespace mlx
{
class Text
{
public:
Text() = default;
void Init(std::string text, FontID font, std::uint32_t color, std::vector<Vertex> vbo_data, std::vector<std::uint16_t> ibo_data);
void Bind(class Renderer& renderer) noexcept;
inline FontID GetFontInUse() const noexcept { return m_font; }
void UpdateVertexData(int frame, std::vector<Vertex> vbo_data);
inline std::uint32_t GetIBOsize() noexcept { return m_ibo.GetSize(); }
inline const std::string& GetText() const { return m_text; }
inline std::uint32_t GetColor() const noexcept { return m_color; }
void Destroy() noexcept;
~Text();
private:
std::array<DeviceVertexBuffer, MAX_FRAMES_IN_FLIGHT> m_vbo;
ConstantIndexBuffer m_ibo;
std::string m_text;
std::uint32_t m_color;
FontID m_font = nullfont;
bool m_is_init = false;
};
}
#endif

62
runtime/Includes/Renderer/Texts/TextDescriptor.h
View File

@@ -1,62 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* TextDescriptor.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/11 00:13:34 by maldavid #+# #+# */
/* Updated: 2024/07/05 14:03:43 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_TEXT_DESCRIPTOR__
#define __MLX_TEXT_DESCRIPTOR__
#include <Utils/CombineHash.h>
#include <Renderer/Core/DrawableResource.h>
#include <Renderer/Texts/TextLibrary.h>
#include <Renderer/Texts/FontLibrary.h>
namespace mlx
{
class TextDrawDescriptor : public DrawableResource
{
friend class std::hash<TextDrawDescriptor>;
public:
TextID id;
std::uint32_t color;
int x;
int y;
public:
TextDrawDescriptor(std::string text, std::uint32_t _color, int _x, int _y);
void Init(FontID font) noexcept;
bool operator==(const TextDrawDescriptor& rhs) const { return m_text == rhs.m_text && x == rhs.x && y == rhs.y && color == rhs.color; }
void Render(Renderer& renderer) override;
void ResetUpdate() override;
TextDrawDescriptor() = default;
private:
std::string m_text;
};
}
namespace std
{
template <>
struct hash<mlx::TextDrawDescriptor>
{
std::size_t operator()(const mlx::TextDrawDescriptor& d) const noexcept
{
std::size_t hash = 0;
mlx::HashCombine(hash, d.x, d.y, d.color, d.m_text);
return hash;
}
};
}
#endif

48
runtime/Includes/Renderer/Texts/TextLibrary.h
View File

@@ -1,48 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* TextLibrary.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/10 11:52:30 by maldavid #+# #+# */
/* Updated: 2024/03/28 22:26:10 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_TEXT_LIBRARY__
#define __MLX_TEXT_LIBRARY__
#include <Renderer/Buffers/VertexBuffer.h>
#include <Renderer/Buffers/IndexBuffer.h>
#include <Renderer/Texts/Font.h>
#include <Renderer/Core/RenderCore.h>
#include <Utils/Singleton.h>
namespace mlx
{
using TextID = std::uint32_t;
constexpr TextID nulltext = 0;
class TextLibrary : public Singleton<TextLibrary>
{
friend class Singleton<TextLibrary>;
public:
std::shared_ptr<class Text> GetTextData(TextID id);
TextID AddTextToLibrary(std::shared_ptr<Text> text);
void RemoveTextFromLibrary(TextID id);
void ClearLibrary();
private:
TextLibrary() = default;
~TextLibrary() = default;
private:
std::unordered_map<TextID, std::shared_ptr<class Text>> m_cache;
TextID m_current_id = 1;
};
}
#endif

43
runtime/Includes/Renderer/Texts/TextManager.h
View File

@@ -1,43 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* TextManager.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/04/06 16:24:11 by maldavid #+# #+# */
/* Updated: 2024/03/28 22:27:32 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_TEXT_MANAGER__
#define __MLX_TEXT_MANAGER__
#include <Renderer/Renderer.h>
#include <Renderer/Images/TextureAtlas.h>
#include <Renderer/Texts/TextDescriptor.h>
#include <Renderer/Texts/TextLibrary.h>
#include <Renderer/Texts/FontLibrary.h>
namespace mlx
{
class TextManager
{
public:
TextManager() = default;
void Init(Renderer& renderer) noexcept;
std::pair<NonOwningPtr<DrawableResource>, bool> RegisterText(int x, int y, std::uint32_t color, std::string str);
inline void Clear() { m_text_descriptors.clear(); }
void LoadFont(Renderer& renderer, const std::filesystem::path& filepath, float scale);
void Destroy() noexcept;
~TextManager() = default;
private:
std::unordered_set<TextDrawDescriptor> m_text_descriptors;
FontID m_font_in_use = nullfont;
};
}
#endif

61
runtime/Includes/Renderer/Vertex.h
View File

@@ -1,60 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Vertex.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/23 22:24:33 by maldavid #+# #+# */
/* Updated: 2024/04/23 22:25:01 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VERTEX__
#define __MLX_VERTEX__
#ifndef __MLX_RENDERER_VERTEX__
#define __MLX_RENDERER_VERTEX__
#include <Maths/Vec4.h>
#include <Maths/Vec2.h>
namespace mlx
{
struct Vertex
{
glm::vec2 pos;
glm::vec4 color;
glm::vec2 uv;
alignas(16) Vec2f position = Vec4f{ 0.0f, 0.0f };
alignas(16) Vec4f color = Vec4f{ 1.0f, 1.0f, 1.0f, 1.0f };
alignas(16) Vec2f uv = Vec2f{ 0.0f, 0.0f };
Vertex(glm::vec2 _pos, glm::vec4 _color, glm::vec2 _uv) : pos(std::move(_pos)), color(std::move(_color)), uv(std::move(_uv)) {}
Vertex() = default;
Vertex(Vec2f p, Vec4f c, Vec2f u) : position(std::move(p)), color(std::move(c)), uv(std::move(u)) {}
static VkVertexInputBindingDescription GetBindingDescription()
{
VkVertexInputBindingDescription binding_description{};
binding_description.binding = 0;
binding_description.stride = sizeof(Vertex);
binding_description.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
return binding_description;
}
static std::array<VkVertexInputAttributeDescription, 3> GetAttributeDescriptions()
{
std::array<VkVertexInputAttributeDescription, 3> attribute_descriptions;
attribute_descriptions[0].binding = 0;
attribute_descriptions[0].location = 0;
attribute_descriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
attribute_descriptions[0].offset = offsetof(Vertex, pos);
attribute_descriptions[1].binding = 0;
attribute_descriptions[1].location = 1;
attribute_descriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
attribute_descriptions[1].offset = offsetof(Vertex, color);
attribute_descriptions[2].binding = 0;
attribute_descriptions[2].location = 2;
attribute_descriptions[2].format = VK_FORMAT_R32G32_SFLOAT;
attribute_descriptions[2].offset = offsetof(Vertex, uv);
return attribute_descriptions;
}
[[nodiscard]] inline static VkVertexInputBindingDescription GetBindingDescription();
[[nodiscard]] inline static std::array<VkVertexInputAttributeDescription, 3> GetAttributeDescriptions();
};
}
#include <Renderer/Vertex.inl>
#endif

36
runtime/Includes/Renderer/Vertex.inl git.filemode.normal_file
View File

@@ -0,0 +1,36 @@
#pragma once
#include <Renderer/Vertex.h>
namespace mlx
{
VkVertexInputBindingDescription Vertex::GetBindingDescription()
{
VkVertexInputBindingDescription binding_description{};
binding_description.binding = 0;
binding_description.stride = sizeof(Vertex);
binding_description.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
return binding_description;
}
std::array<VkVertexInputAttributeDescription, 3> Vertex::GetAttributeDescriptions()
{
std::array<VkVertexInputAttributeDescription, 3> attribute_descriptions;
attribute_descriptions[0].binding = 0;
attribute_descriptions[0].location = 0;
attribute_descriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
attribute_descriptions[0].offset = offsetof(Vertex, position);
attribute_descriptions[1].binding = 0;
attribute_descriptions[1].location = 1;
attribute_descriptions[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
attribute_descriptions[1].offset = offsetof(Vertex, color);
attribute_descriptions[2].binding = 0;
attribute_descriptions[2].location = 2;
attribute_descriptions[2].format = VK_FORMAT_R32G32_SFLOAT;
attribute_descriptions[2].offset = offsetof(Vertex, uv);
return attribute_descriptions;
}
}

14
runtime/Includes/Renderer/ViewerData.h git.filemode.normal_file
View File

@@ -0,0 +1,14 @@
#ifndef __MLX_VIEWER_DATA__
#define __MLX_VIEWER_DATA__
#include <Maths/Mat4.h>
namespace mlx
{
struct ViewerData
{
Mat4f projection_matrix;
};
}
#endif

170
runtime/Includes/Renderer/Vulkan/VulkanPrototypes.h git.filemode.normal_file
View File

@@ -0,0 +1,170 @@
#ifndef __SCOP_VK_PROTOTYPES__
#define __SCOP_VK_PROTOTYPES__
#if defined(VULKAN_H_) && !defined(VK_NO_PROTOTYPES)
#error "define VK_NO_PROTOTYPES needed"
#endif
#ifndef VK_NO_PROTOTYPES
#define VK_NO_PROTOTYPES
#endif
#ifndef VULKAN_H_
#include <vulkan/vulkan.h>
#endif
#if defined(VK_VERSION_1_0)
extern PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers;
extern PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets;
extern PFN_vkAllocateMemory vkAllocateMemory;
extern PFN_vkBeginCommandBuffer vkBeginCommandBuffer;
extern PFN_vkBindBufferMemory vkBindBufferMemory;
extern PFN_vkBindImageMemory vkBindImageMemory;
extern PFN_vkCmdBeginQuery vkCmdBeginQuery;
extern PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass;
extern PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets;
extern PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer;
extern PFN_vkCmdBindPipeline vkCmdBindPipeline;
extern PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers;
extern PFN_vkCmdBlitImage vkCmdBlitImage;
extern PFN_vkCmdClearAttachments vkCmdClearAttachments;
extern PFN_vkCmdClearColorImage vkCmdClearColorImage;
extern PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage;
extern PFN_vkCmdCopyBuffer vkCmdCopyBuffer;
extern PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage;
extern PFN_vkCmdCopyImage vkCmdCopyImage;
extern PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer;
extern PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults;
extern PFN_vkCmdDispatch vkCmdDispatch;
extern PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect;
extern PFN_vkCmdDraw vkCmdDraw;
extern PFN_vkCmdDrawIndexed vkCmdDrawIndexed;
extern PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect;
extern PFN_vkCmdDrawIndirect vkCmdDrawIndirect;
extern PFN_vkCmdEndQuery vkCmdEndQuery;
extern PFN_vkCmdEndRenderPass vkCmdEndRenderPass;
extern PFN_vkCmdExecuteCommands vkCmdExecuteCommands;
extern PFN_vkCmdFillBuffer vkCmdFillBuffer;
extern PFN_vkCmdNextSubpass vkCmdNextSubpass;
extern PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier;
extern PFN_vkCmdPushConstants vkCmdPushConstants;
extern PFN_vkCmdResetEvent vkCmdResetEvent;
extern PFN_vkCmdResetQueryPool vkCmdResetQueryPool;
extern PFN_vkCmdResolveImage vkCmdResolveImage;
extern PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants;
extern PFN_vkCmdSetDepthBias vkCmdSetDepthBias;
extern PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds;
extern PFN_vkCmdSetEvent vkCmdSetEvent;
extern PFN_vkCmdSetLineWidth vkCmdSetLineWidth;
extern PFN_vkCmdSetScissor vkCmdSetScissor;
extern PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask;
extern PFN_vkCmdSetStencilReference vkCmdSetStencilReference;
extern PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask;
extern PFN_vkCmdSetViewport vkCmdSetViewport;
extern PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer;
extern PFN_vkCmdWaitEvents vkCmdWaitEvents;
extern PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp;
extern PFN_vkCreateBuffer vkCreateBuffer;
extern PFN_vkCreateBufferView vkCreateBufferView;
extern PFN_vkCreateCommandPool vkCreateCommandPool;
extern PFN_vkCreateComputePipelines vkCreateComputePipelines;
extern PFN_vkCreateDescriptorPool vkCreateDescriptorPool;
extern PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout;
extern PFN_vkCreateDevice vkCreateDevice;
extern PFN_vkCreateEvent vkCreateEvent;
extern PFN_vkCreateFence vkCreateFence;
extern PFN_vkCreateFramebuffer vkCreateFramebuffer;
extern PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines;
extern PFN_vkCreateImage vkCreateImage;
extern PFN_vkCreateImageView vkCreateImageView;
extern PFN_vkCreateInstance vkCreateInstance;
extern PFN_vkCreatePipelineCache vkCreatePipelineCache;
extern PFN_vkCreatePipelineLayout vkCreatePipelineLayout;
extern PFN_vkCreateQueryPool vkCreateQueryPool;
extern PFN_vkCreateRenderPass vkCreateRenderPass;
extern PFN_vkCreateSampler vkCreateSampler;
extern PFN_vkCreateSemaphore vkCreateSemaphore;
extern PFN_vkCreateShaderModule vkCreateShaderModule;
extern PFN_vkDestroyBuffer vkDestroyBuffer;
extern PFN_vkDestroyBufferView vkDestroyBufferView;
extern PFN_vkDestroyCommandPool vkDestroyCommandPool;
extern PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool;
extern PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout;
extern PFN_vkDestroyDevice vkDestroyDevice;
extern PFN_vkDestroyEvent vkDestroyEvent;
extern PFN_vkDestroyFence vkDestroyFence;
extern PFN_vkDestroyFramebuffer vkDestroyFramebuffer;
extern PFN_vkDestroyImage vkDestroyImage;
extern PFN_vkDestroyImageView vkDestroyImageView;
extern PFN_vkDestroyInstance vkDestroyInstance;
extern PFN_vkDestroyPipeline vkDestroyPipeline;
extern PFN_vkDestroyPipelineCache vkDestroyPipelineCache;
extern PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout;
extern PFN_vkDestroyQueryPool vkDestroyQueryPool;
extern PFN_vkDestroyRenderPass vkDestroyRenderPass;
extern PFN_vkDestroySampler vkDestroySampler;
extern PFN_vkDestroySemaphore vkDestroySemaphore;
extern PFN_vkDestroyShaderModule vkDestroyShaderModule;
extern PFN_vkDeviceWaitIdle vkDeviceWaitIdle;
extern PFN_vkEndCommandBuffer vkEndCommandBuffer;
extern PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties;
extern PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties;
extern PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties;
extern PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties;
extern PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices;
extern PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
extern PFN_vkFreeCommandBuffers vkFreeCommandBuffers;
extern PFN_vkFreeDescriptorSets vkFreeDescriptorSets;
extern PFN_vkFreeMemory vkFreeMemory;
extern PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
extern PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment;
extern PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr;
extern PFN_vkGetDeviceQueue vkGetDeviceQueue;
extern PFN_vkGetEventStatus vkGetEventStatus;
extern PFN_vkGetFenceStatus vkGetFenceStatus;
extern PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
extern PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements;
extern PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout;
extern PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
extern PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures;
extern PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties;
extern PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties;
extern PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties;
extern PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties;
extern PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties;
extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties;
extern PFN_vkGetPipelineCacheData vkGetPipelineCacheData;
extern PFN_vkGetQueryPoolResults vkGetQueryPoolResults;
extern PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity;
extern PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
extern PFN_vkMapMemory vkMapMemory;
extern PFN_vkMergePipelineCaches vkMergePipelineCaches;
extern PFN_vkQueueBindSparse vkQueueBindSparse;
extern PFN_vkQueueSubmit vkQueueSubmit;
extern PFN_vkQueueWaitIdle vkQueueWaitIdle;
extern PFN_vkResetCommandBuffer vkResetCommandBuffer;
extern PFN_vkResetCommandPool vkResetCommandPool;
extern PFN_vkResetDescriptorPool vkResetDescriptorPool;
extern PFN_vkResetEvent vkResetEvent;
extern PFN_vkResetFences vkResetFences;
extern PFN_vkSetEvent vkSetEvent;
extern PFN_vkUnmapMemory vkUnmapMemory;
extern PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets;
extern PFN_vkWaitForFences vkWaitForFences;
#endif /* defined(VK_VERSION_1_0) */
#if defined(VK_KHR_swapchain)
extern PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR;
extern PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR;
extern PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR;
extern PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR;
extern PFN_vkQueuePresentKHR vkQueuePresentKHR;
#endif /* defined(VK_KHR_swapchain) */
#if defined(VK_KHR_surface)
extern PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
extern PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
extern PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR;
extern PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR;
extern PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
#endif /* defined(VK_KHR_surface) */
#endif