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

fixing compatibility, workign on renderer

Browse Source
This commit is contained in:
Kbz-8
2022-12-18 04:04:10 +01:00
parent f52c4e51c9
commit 4a67aab716
48 changed files with 6535 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
src/renderer/buffers/vk_buffer.cpp git.filemode.normal_file
View File

@@ -0,0 +1,93 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_buffer.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 18:55:57 by maldavid #+# #+# */
/* Updated: 2022/12/18 02:10:37 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include "vk_buffer.h"
#include <cstring>
namespace mlx
{
void Buffer::create(Buffer::kind type, VkDeviceSize size, VkBufferUsageFlags usage, const void* data)
{
if(type == Buffer::kind::uniform)
{
_usage = usage;
_flags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
}
else
{
_usage = usage;
_flags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
}
_size = size;
createBuffer(_usage, _flags);
}
void Buffer::destroy() noexcept
{
vkDestroyBuffer(Render_Core::get().getDevice().get(), _buffer, nullptr);
vkFreeMemory(Render_Core::get().getDevice().get(), _memory, nullptr);
}
uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties)
{
VkPhysicalDeviceMemoryProperties memProperties;
vkGetPhysicalDeviceMemoryProperties(Render_Core::get().getDevice().getPhysicalDevice(), &memProperties);
for(uint32_t i = 0; i < memProperties.memoryTypeCount; i++)
{
if((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties)
return i;
}
core::error::report(e_kind::fatal_error, "Vulkan : failed to find suitable memory type");
return -1; // just to avoid warning
}
void Buffer::createBuffer(VkBufferUsageFlags usage, VkMemoryPropertyFlags properties)
{
VkBufferCreateInfo bufferInfo{};
bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bufferInfo.size = _size;
bufferInfo.usage = usage;
bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
auto device = Render_Core::get().getDevice().get();
if(vkCreateBuffer(device, &bufferInfo, nullptr, &_buffer) != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : failed to create buffer");
VkMemoryRequirements memRequirements;
vkGetBufferMemoryRequirements(device, _buffer, &memRequirements);
VkMemoryAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);
if(vkAllocateMemory(device, &allocInfo, nullptr, &_memory) != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : failed to allocate buffer memory");
if(vkBindBufferMemory(device, _buffer, _memory, _offset) != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : unable to bind device memory to a buffer object");
}
void Buffer::flush(VkDeviceSize size, VkDeviceSize offset)
{
VkMappedMemoryRange mappedRange{};
mappedRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
mappedRange.memory = _memory;
mappedRange.offset = offset;
mappedRange.size = size;
vkFlushMappedMemoryRanges(Render_Core::get().getDevice().get(), 1, &mappedRange);
}
}

58
src/renderer/buffers/vk_buffer.h git.filemode.normal_file
View File

@@ -0,0 +1,58 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_buffer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 23:18:52 by maldavid #+# #+# */
/* Updated: 2022/12/18 02:10:08 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_BUFFER__
#define __MLX_VK_BUFFER__
#include <volk.h>
#include <renderer/core/render_core.h>
namespace mlx
{
class Buffer
{
public:
enum class kind { dynamic, uniform };
void create(kind type, VkDeviceSize size, VkBufferUsageFlags usage, const void* data = nullptr);
void destroy() noexcept;
inline void mapMem(void** data = nullptr, VkDeviceSize size = VK_WHOLE_SIZE, VkDeviceSize offset = 0) noexcept
{
if(vkMapMemory(Render_Core::get().getDevice().get(), _memory, _offset + offset, size, 0, data) != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : failed to map a buffer");
}
inline void unmapMem() noexcept { vkUnmapMemory(Render_Core::get().getDevice().get(), _memory); }
void flush(VkDeviceSize size = VK_WHOLE_SIZE, VkDeviceSize offset = 0);
inline unsigned int getSize() noexcept { return _size; }
inline unsigned int getOffset() noexcept { return _offset; }
inline VkDeviceMemory getDeviceMemory() noexcept { return _memory; }
inline VkBuffer& operator()() noexcept { return _buffer; }
inline VkBuffer& get() noexcept { return _buffer; }
protected:
VkDeviceMemory _memory = VK_NULL_HANDLE;
VkDeviceSize _offset = 0;
VkDeviceSize _size = 0;
VkBuffer _buffer = VK_NULL_HANDLE;
private:
void createBuffer(VkBufferUsageFlags usage, VkMemoryPropertyFlags properties);
VkBufferUsageFlags _usage = 0;
VkMemoryPropertyFlags _flags = 0;
};
}
#endif

34
src/renderer/buffers/vk_ubo.cpp git.filemode.normal_file
View File

@@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_ubo.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:45:52 by maldavid #+# #+# */
/* Updated: 2022/12/18 00:25:55 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include "vk_ubo.h"
#include <cstring>
namespace mlx
{
void UBO::setData(uint32_t size, const void* data)
{
void* temp = nullptr;
mapMem(&temp);
std::memcpy(temp, data, static_cast<size_t>(size));
unmapMem();
}
void UBO::setDynamicData(uint32_t size, uint32_t typeSize, const void* data)
{
void* temp = nullptr;
mapMem(&temp);
std::memcpy(temp, data, static_cast<size_t>(size));
Buffer::flush();
unmapMem();
}
}

30
src/renderer/buffers/vk_ubo.h git.filemode.normal_file
View File

@@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_ubo.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:45:29 by maldavid #+# #+# */
/* Updated: 2022/10/06 18:45:49 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_UBO__
#define __MLX_VK_UBO__
#include "vk_buffer.h"
namespace mlx
{
class UBO : public Buffer
{
public:
inline void create(uint32_t size) { Buffer::create(Buffer::kind::dynamic, size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT); }
void setData(uint32_t size, const void* data);
void setDynamicData(uint32_t size, uint32_t typeSize, const void* data);
};
}
#endif // __MLX_VK_UBO__

49
src/renderer/buffers/vk_vbo.cpp git.filemode.normal_file
View File

@@ -0,0 +1,49 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_vbo.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:28:08 by maldavid #+# #+# */
/* Updated: 2022/12/18 00:28:52 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include "vk_vbo.h"
#include <cstring>
namespace mlx
{
void VBO::setData(uint32_t size, const void* data)
{
if(size > _size)
core::error::report(e_kind::error, "Vulkan : trying to store to much data in a vertex buffer (%d on %d)", size, _size);
if(data == nullptr)
core::error::report(e_kind::warning, "Vulkan : mapping null data in a vertex buffer");
void* temp = nullptr;
mapMem(&temp);
std::memcpy(temp, data, static_cast<size_t>(size));
unmapMem();
_used_size += size;
}
void VBO::setSubData(uint32_t offset, uint32_t size, const void* data)
{
if(size + _used_size > _size)
core::error::report(e_kind::error, "Vulkan : trying to store to much data in a vertex buffer (%d on %d)", size + _used_size, _size);
if(data == nullptr)
core::error::report(e_kind::warning, "Vulkan : mapping null data in a vertex buffer");
void* temp = nullptr;
mapMem(&temp, size, offset);
std::memcpy(temp, data, static_cast<size_t>(size));
unmapMem();
_used_size += size;
}
}

35
src/renderer/buffers/vk_vbo.h git.filemode.normal_file
View File

@@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_vbo.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:27:38 by maldavid #+# #+# */
/* Updated: 2022/12/18 02:51:53 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __MLX_VK_VBO__
#define __MLX_VK_VBO__
#include "vk_buffer.h"
namespace mlx
{
class VBO : public Buffer
{
public:
inline void create(uint32_t size) { Buffer::create(Buffer::kind::dynamic, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT); }
void setData(uint32_t size, const void* data);
void setSubData(uint32_t offset, uint32_t size, const void* data);
inline void bind() noexcept { vkCmdBindVertexBuffers(Render_Core::get().getActiveCmdBuffer().get(), 0, 1, &_buffer, &_offset); }
private:
uint32_t _used_size = 0;
};
}
#endif // __MLX_VK_VBO__