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

adding vulkan images, start using images for put_pixel

Browse Source
This commit is contained in:
Kbz-8
2023-01-25 21:46:58 +01:00
parent 659f6cc14e
commit b170354e7f
16 changed files with 374 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
src/platform/window.cpp
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/04 17:36:44 by maldavid #+# #+# */
/* Updated: 2023/01/24 17:57:19 by maldavid ### ########.fr */
/* Updated: 2023/01/25 16:27:23 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
@@ -17,51 +17,87 @@
#include <glm/gtc/type_ptr.hpp>
#include <iostream>
#include <cstring>
namespace mlx
{
MLX_Window::MLX_Window(std::size_t w, std::size_t h, std::string title, int id) : _id(id), _renderer(new Renderer()), _width(w), _height(h)
MLX_Window::MLX_Window(std::size_t w, std::size_t h, std::string title, int id) : _id(id), _renderer(new Renderer), _width(w), _height(h)
{
_win = SDL_CreateWindow(title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, SDL_WINDOW_VULKAN | SDL_WINDOW_SHOWN);
if(!_win)
core::error::report(e_kind::fatal_error, std::string("Unable to open a new window, ") + SDL_GetError());
core::error::report(e_kind::fatal_error, std::string("unable to open a new window, ") + SDL_GetError());
_renderer->setWindow(this);
_renderer->init();
_vbo.create(sizeof(Vertex));
std::vector<Vertex> vertexData = {
{{0, 0}, {1.f, 0.f, 0.f}},
{{_width, 0}, {1.f, 0.f, 0.f}},
{{_width, _height}, {1.f, 0.f, 0.f}},
{{0, _height}, {1.f, 0.f, 0.}}
};
std::vector<uint16_t> indexData = { 0, 1, 2, 2, 3, 0 };
_vbo.create(sizeof(Vertex) * vertexData.size(), vertexData.data());
_ibo.create(sizeof(uint16_t) * indexData.size(), indexData.data());
//_vk_image.create(_width, _height);
_staging_buffer.create(Buffer::kind::dynamic, sizeof(uint32_t) * 4, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
}
bool MLX_Window::beginFrame()
{
bool success = _renderer->beginFrame();
if(success)
_vbo.bind(*_renderer);
if(!_renderer->beginFrame())
return false;
_proj = glm::ortho<float>(0, _width, 0, _height);
_renderer->getUniformBuffer()->setData(sizeof(_proj), &_proj);
vkCmdBindDescriptorSets(_renderer->getActiveCmdBuffer().get(), VK_PIPELINE_BIND_POINT_GRAPHICS, _renderer->getPipeline().getPipelineLayout(), 0, 1, &_renderer->getDescriptorSet().get(), 0, nullptr);
return success;
return true;
}
void MLX_Window::pixel_put(int x, int y, int color)
{
static Vertex vert;
vert.pos = glm::vec2(x, y);
vert.color.r = (color >> 16) & 0xFF;
vert.color.g = (color >> 8) & 0xFF;
vert.color.b = color & 0xFF;
_vbo.setData(sizeof(Vertex), &vert);
VkBufferImageCopy region{};
region.bufferOffset = 0;
region.bufferRowLength = 0;
region.bufferImageHeight = 0;
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.imageSubresource.mipLevel = 0;
region.imageSubresource.baseArrayLayer = 0;
region.imageSubresource.layerCount = 1;
region.imageOffset = {x, y, 0};
region.imageExtent = {1, 1, 1};
vkCmdDraw(_renderer->getActiveCmdBuffer().get(), 1, 1, 0, 0);
VkClearColorValue vk_color;
vk_color.uint32[0] = (color >> 16) & 0xFF;
vk_color.uint32[1] = (color >> 8) & 0xFF;
vk_color.uint32[2] = color & 0xFF;
vk_color.uint32[3] = 0xFF;
void* map = nullptr;
_staging_buffer.mapMem(&map, sizeof(vk_color));
std::memcpy(map, &vk_color, sizeof(vk_color));
_staging_buffer.unmapMem();
vkCmdCopyBufferToImage(_renderer->getActiveCmdBuffer().get(), _staging_buffer.get(), _vk_image.get(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &region);
}
void MLX_Window::endFrame()
{
_vbo.bind(*_renderer);
_ibo.bind(*_renderer);
vkCmdDrawIndexed(_renderer->getActiveCmdBuffer().get(), static_cast<uint32_t>(_ibo.getSize() / sizeof(uint16_t)), 1, 0, 0, 0);
_renderer->endFrame();
}
MLX_Window::~MLX_Window()
{
_renderer->destroy();
//_vk_image.destroy();
_staging_buffer.destroy();
_vbo.destroy();
_ibo.destroy();
if(_win)
SDL_DestroyWindow(_win);
}

12
src/platform/window.h
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/04 21:53:12 by maldavid #+# #+# */
/* Updated: 2023/01/24 17:15:09 by maldavid ### ########.fr */
/* Updated: 2023/01/25 15:15:25 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
@@ -17,7 +17,10 @@
#include <string>
#include <memory>
#include <renderer/renderer.h>
#include <renderer/images/vk_image.h>
#include <renderer/buffers/vk_buffer.h>
#include <renderer/buffers/vk_vbo.h>
#include <renderer/buffers/vk_ibo.h>
namespace mlx
{
@@ -37,9 +40,12 @@ namespace mlx
~MLX_Window();
private:
std::unique_ptr<Renderer> _renderer;
Image _vk_image;
Buffer _staging_buffer;
C_VBO _vbo;
C_IBO _ibo;
glm::mat4 _proj = glm::mat4(1.0);
VBO _vbo;
std::unique_ptr<Renderer> _renderer;
SDL_Window* _win = nullptr;
int _width = 0;
int _height = 0;

121
src/renderer/buffers/vk_buffer.cpp
View File

@@ -6,18 +6,30 @@
/* 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 */
/* Updated: 2023/01/25 15:24:40 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include "vk_buffer.h"
#include <renderer/command/vk_cmd_pool.h>
#include <renderer/core/render_core.h>
#include <cstring>
namespace mlx
{
void Buffer::create(Buffer::kind type, VkDeviceSize size, VkBufferUsageFlags usage, const void* data)
{
if(type == Buffer::kind::uniform)
if(type == Buffer::kind::constant)
{
if(data == nullptr)
{
core::error::report(e_kind::warning, "Vulkan : trying to create constant buffer without data (constant buffers cannot be modified after creation)");
return;
}
_usage = usage | VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
_flags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
}
else if(type == Buffer::kind::uniform)
{
_usage = usage;
_flags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
@@ -31,6 +43,17 @@ namespace mlx
_size = size;
createBuffer(_usage, _flags);
if(type == Buffer::kind::constant || data != nullptr)
{
void* mapped = nullptr;
mapMem(&mapped);
std::memcpy(mapped, data, _size);
unmapMem();
if(type == Buffer::kind::constant)
pushToGPU();
}
}
void Buffer::destroy() noexcept
@@ -39,21 +62,6 @@ namespace mlx
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{};
@@ -73,7 +81,7 @@ namespace mlx
VkMemoryAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);
allocInfo.memoryTypeIndex = RCore::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");
@@ -81,6 +89,83 @@ namespace mlx
core::error::report(e_kind::fatal_error, "Vulkan : unable to bind device memory to a buffer object");
}
void Buffer::pushToGPU() noexcept
{
Buffer newBuffer;
newBuffer._size = _size;
newBuffer._usage = (this->_usage & 0xFFFFFFFC) | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
newBuffer._flags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
newBuffer.createBuffer(newBuffer._usage, newBuffer._flags);
CmdPool cmdpool;
cmdpool.init();
auto device = Render_Core::get().getDevice().get();
VkCommandBufferAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocInfo.commandPool = cmdpool.get();
allocInfo.commandBufferCount = 1;
VkCommandBuffer commandBuffer;
vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);
VkCommandBufferBeginInfo beginInfo{};
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkBeginCommandBuffer(commandBuffer, &beginInfo);
VkBufferCopy copyRegion{};
copyRegion.size = _size;
vkCmdCopyBuffer(commandBuffer, _buffer, newBuffer._buffer, 1, &copyRegion);
vkEndCommandBuffer(commandBuffer);
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &commandBuffer;
auto graphicsQueue = Render_Core::get().getQueue().getGraphic();
vkQueueSubmit(graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);
vkQueueWaitIdle(graphicsQueue);
cmdpool.destroy();
this->swap(newBuffer);
newBuffer.destroy();
}
void Buffer::swap(Buffer& buffer) noexcept
{
VkBuffer temp_b = _buffer;
_buffer = buffer._buffer;
buffer._buffer = temp_b;
VkDeviceSize temp_size = buffer._size;
buffer._size = _size;
_size = temp_size;
VkDeviceSize temp_offset = buffer._offset;
buffer._offset = _offset;
_offset = temp_offset;
VkDeviceMemory temp_memory = buffer._memory;
buffer._memory = _memory;
_memory = temp_memory;
VkBufferUsageFlags temp_u = _usage;
_usage = buffer._usage;
buffer._usage = temp_u;
VkMemoryPropertyFlags temp_f = _flags;
_flags = buffer._flags;
buffer._flags = temp_f;
}
void Buffer::flush(VkDeviceSize size, VkDeviceSize offset)
{
VkMappedMemoryRange mappedRange{};

7
src/renderer/buffers/vk_buffer.h
View File

@@ -6,7 +6,7 @@
/* 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 */
/* Updated: 2023/01/25 15:36:47 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
@@ -21,7 +21,7 @@ namespace mlx
class Buffer
{
public:
enum class kind { dynamic, uniform };
enum class kind { dynamic, uniform, constant };
void create(kind type, VkDeviceSize size, VkBufferUsageFlags usage, const void* data = nullptr);
void destroy() noexcept;
@@ -42,6 +42,9 @@ namespace mlx
inline VkBuffer& get() noexcept { return _buffer; }
protected:
void pushToGPU() noexcept;
void swap(Buffer& buffer) noexcept;
VkDeviceMemory _memory = VK_NULL_HANDLE;
VkDeviceSize _offset = 0;
VkDeviceSize _size = 0;

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

@@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_ibo.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/25 15:05:05 by maldavid #+# #+# */
/* Updated: 2023/01/25 15:36:41 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __VK_IBO__
#define __VK_IBO__
#include <volk.h>
#include "vk_buffer.h"
#include <renderer/renderer.h>
namespace mlx
{
class C_IBO : public Buffer
{
public:
inline void create(uint32_t size, const uint16_t* data) { Buffer::create(Buffer::kind::constant, size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, data); }
inline void bind(Renderer& renderer) noexcept { vkCmdBindIndexBuffer(renderer.getActiveCmdBuffer().get(), _buffer, _offset, VK_INDEX_TYPE_UINT16); }
};
}
#endif

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

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:45:29 by maldavid #+# #+# */
/* Updated: 2023/01/23 18:54:08 by maldavid ### ########.fr */
/* Updated: 2023/01/25 15:37:09 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */

9
src/renderer/buffers/vk_vbo.h
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:27:38 by maldavid #+# #+# */
/* Updated: 2022/12/19 15:16:42 by maldavid ### ########.fr */
/* Updated: 2023/01/25 15:37:00 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
@@ -27,6 +27,13 @@ namespace mlx
inline void bind(Renderer& renderer) noexcept { vkCmdBindVertexBuffers(renderer.getActiveCmdBuffer().get(), 0, 1, &_buffer, &_offset); }
};
class C_VBO : public Buffer
{
public:
inline void create(uint32_t size, const void* data) { Buffer::create(Buffer::kind::constant, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, data); }
inline void bind(Renderer& renderer) noexcept { vkCmdBindVertexBuffers(renderer.getActiveCmdBuffer().get(), 0, 1, &_buffer, &_offset); }
};
}
#endif // __MLX_VK_VBO__

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

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/17 23:33:34 by maldavid #+# #+# */
/* Updated: 2023/01/23 18:28:12 by maldavid ### ########.fr */
/* Updated: 2023/01/25 15:24:19 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
@@ -27,45 +27,21 @@ namespace mlx
{
namespace RCore
{
const char* verbaliseResultVk(VkResult result)
uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties)
{
switch(result)
VkPhysicalDeviceMemoryProperties memProperties;
vkGetPhysicalDeviceMemoryProperties(Render_Core::get().getDevice().getPhysicalDevice(), &memProperties);
for(uint32_t i = 0; i < memProperties.memoryTypeCount; i++)
{
case VK_SUCCESS: return "Success";
case VK_NOT_READY: return "A fence or query has not yet completed";
case VK_TIMEOUT: return "A wait operation has not completed in the specified time";
case VK_EVENT_SET: return "An event is signaled";
case VK_EVENT_RESET: return "An event is unsignaled";
case VK_INCOMPLETE: return "A return array was too small for the result";
case VK_ERROR_OUT_OF_HOST_MEMORY: return "A host memory allocation has failed";
case VK_ERROR_OUT_OF_DEVICE_MEMORY: return "A device memory allocation has failed";
case VK_ERROR_INITIALIZATION_FAILED: return "Initialization of an object could not be completed for implementation-specific reasons";
case VK_ERROR_DEVICE_LOST: return "The logical or physical device has been lost";
case VK_ERROR_MEMORY_MAP_FAILED: return "Mapping of a memory object has failed";
case VK_ERROR_LAYER_NOT_PRESENT: return "A requested layer is not present or could not be loaded";
case VK_ERROR_EXTENSION_NOT_PRESENT: return "A requested extension is not supported";
case VK_ERROR_FEATURE_NOT_PRESENT: return "A requested feature is not supported";
case VK_ERROR_INCOMPATIBLE_DRIVER: return "The requested version of Vulkan is not supported by the driver or is otherwise incompatible";
case VK_ERROR_TOO_MANY_OBJECTS: return "Too many objects of the type have already been created";
case VK_ERROR_FORMAT_NOT_SUPPORTED: return "A requested format is not supported on this device";
case VK_ERROR_SURFACE_LOST_KHR: return "A surface is no longer available";
case VK_SUBOPTIMAL_KHR: return "A swapchain no longer matches the surface properties exactly, but can still be used";
case VK_ERROR_OUT_OF_DATE_KHR: return "A surface has changed in such a way that it is no longer compatible with the swapchain";
case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: return "The display used by a swapchain does not use the same presentable image layout";
case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: return "The requested window is already connected to a VkSurfaceKHR, or to some other non-Vulkan API";
case VK_ERROR_VALIDATION_FAILED_EXT: return "A validation layer found an error";
default: return "Unknown Vulkan error";
if((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties)
return i;
}
}
void checkVk(VkResult result)
{
if(result != 0)
core::error::report(result < 0 ? e_kind::fatal_error : e_kind::error, "Vulkan error : %s", verbaliseResultVk(result));
core::error::report(e_kind::fatal_error, "Vulkan : failed to find suitable memory type");
return -1; // just to avoid warning
}
}
void Render_Core::init()
{
volkInitialize();

10
src/renderer/core/render_core.h
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 19:16:32 by maldavid #+# #+# */
/* Updated: 2022/12/19 14:16:25 by maldavid ### ########.fr */
/* Updated: 2023/01/25 15:23:19 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
@@ -25,10 +25,10 @@
namespace mlx
{
namespace RCore
{
void checkVk(VkResult result);
}
namespace RCore
{
uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties);
}
#ifndef NDEBUG
constexpr const bool enableValidationLayers = true;

6
src/renderer/core/vk_instance.cpp
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/08 19:04:21 by maldavid #+# #+# */
/* Updated: 2022/12/19 14:26:31 by maldavid ### ########.fr */
/* Updated: 2023/01/25 15:28:18 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
@@ -17,8 +17,6 @@
namespace mlx
{
namespace RCore { const char* verbaliseResultVk(VkResult result); }
void Instance::init()
{
VkApplicationInfo appInfo{};
@@ -56,7 +54,7 @@ namespace mlx
VkResult res;
if((res = vkCreateInstance(&createInfo, nullptr, &_instance)) != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : failed to create Vulkan instance : %s", RCore::verbaliseResultVk(res));
core::error::report(e_kind::fatal_error, "Vulkan : failed to create Vulkan instance");
volkLoadInstance(_instance);
}

91
src/renderer/images/vk_image.cpp git.filemode.normal_file
View File

@@ -0,0 +1,91 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_image.cpp :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/25 11:59:07 by maldavid #+# #+# */
/* Updated: 2023/01/25 12:01:03 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#include "vk_image.h"
#include <renderer/core/render_core.h>
namespace mlx
{
VkFormat findSupportedFormat(const std::vector<VkFormat>& candidates, VkImageTiling tiling, VkFormatFeatureFlags features)
{
for(VkFormat format : candidates)
{
VkFormatProperties props;
vkGetPhysicalDeviceFormatProperties(Render_Core::get().getDevice().getPhysicalDevice(), format, &props);
if(tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures & features) == features)
return format;
else if(tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures & features) == features)
return format;
}
core::error::report(e_kind::fatal_error, "Vulkan : failed to find image format");
}
void Image::create(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, VkImageAspectFlags aspectFlags)
{
_width = width;
_height = height;
_format = format;
VkImageCreateInfo imageInfo{};
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageInfo.imageType = VK_IMAGE_TYPE_2D;
imageInfo.extent.width = width;
imageInfo.extent.height = height;
imageInfo.extent.depth = 1;
imageInfo.mipLevels = 1;
imageInfo.arrayLayers = 1;
imageInfo.format = format;
imageInfo.tiling = tiling;
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageInfo.usage = usage;
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
if(vkCreateImage(Render_Core::get().getDevice().get(), &imageInfo, nullptr, &_image) != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : failed to create an image");
VkMemoryRequirements memRequirements;
vkGetImageMemoryRequirements(Render_Core::get().getDevice().get(), _image, &memRequirements);
VkMemoryAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = RCore::findMemoryType(memRequirements.memoryTypeBits, properties);
if(vkAllocateMemory(Render_Core::get().getDevice().get(), &allocInfo, nullptr, &_memory) != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : failed to allocate memory for an image");
vkBindImageMemory(Render_Core::get().getDevice().get(), _image, _memory, 0);
VkImageViewCreateInfo viewInfo{};
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
viewInfo.image = _image;
viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
viewInfo.format = format;
viewInfo.subresourceRange.aspectMask = aspectFlags;
viewInfo.subresourceRange.baseMipLevel = 0;
viewInfo.subresourceRange.levelCount = 1;
viewInfo.subresourceRange.baseArrayLayer = 0;
viewInfo.subresourceRange.layerCount = 1;
if(vkCreateImageView(Render_Core::get().getDevice().get(), &viewInfo, nullptr, &_image_view) != VK_SUCCESS)
core::error::report(e_kind::fatal_error, "Vulkan : failed to create an image view");
}
void Image::destroy() noexcept
{
vkDestroyImage(Render_Core::get().getDevice().get(), _image, nullptr);
vkFreeMemory(Render_Core::get().getDevice().get(), _memory, nullptr);
vkDestroyImageView(Render_Core::get().getDevice().get(), _image_view, nullptr);
}
}

52
src/renderer/images/vk_image.h git.filemode.normal_file
View File

@@ -0,0 +1,52 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vk_image.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/01/25 11:54:21 by maldavid #+# #+# */
/* Updated: 2023/01/25 11:56:03 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef __VK_IMAGE__
#define __VK_IMAGE__
#include <volk.h>
#include <cstddef>
#include <vector>
namespace mlx
{
VkFormat findSupportedFormat(const std::vector<VkFormat>& candidates, VkImageTiling tiling, VkFormatFeatureFlags features);
class Image
{
public:
Image() = default;
virtual void create(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, VkImageAspectFlags aspectFlags);
void destroy() noexcept;
void copyBuffer(class Buffer& buffer);
inline VkImage& get() noexcept { return _image; }
inline VkImage& operator()() noexcept { return _image; }
inline VkDeviceMemory getDeviceMemory() noexcept { return _memory; }
inline VkImageView& getImageView() noexcept { return _image_view; }
inline VkFormat& getFormat() noexcept { return _format; }
virtual ~Image() = default;
private:
VkImage _image = VK_NULL_HANDLE;
VkDeviceMemory _memory = VK_NULL_HANDLE;
VkImageView _image_view = VK_NULL_HANDLE;
uint32_t _width = 0;
uint32_t _height = 0;
VkFormat _format;
};
}
#endif

6
src/renderer/pipeline/pipeline.cpp
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/18 21:27:38 by maldavid #+# #+# */
/* Updated: 2023/01/24 16:42:19 by maldavid ### ########.fr */
/* Updated: 2023/01/25 16:19:33 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
@@ -157,9 +157,9 @@ namespace mlx
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
rasterizer.depthClampEnable = VK_FALSE;
rasterizer.rasterizerDiscardEnable = VK_FALSE;
rasterizer.polygonMode = VK_POLYGON_MODE_FILL; //VK_POLYGON_MODE_POINT;
rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
rasterizer.lineWidth = 1.0f;
rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
rasterizer.cullMode = VK_CULL_MODE_NONE;
rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;
rasterizer.depthBiasEnable = VK_FALSE;

2
src/renderer/renderer.h
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/18 17:14:45 by maldavid #+# #+# */
/* Updated: 2023/01/24 17:21:02 by maldavid ### ########.fr */
/* Updated: 2023/01/25 16:05:05 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */

4
src/renderer/swapchain/vk_swapchain.cpp
View File

@@ -6,7 +6,7 @@
/* By: maldavid <kbz_8.dev@akel-engine.com> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/10/06 18:22:28 by maldavid #+# #+# */
/* Updated: 2022/12/19 15:01:34 by maldavid ### ########.fr */
/* Updated: 2023/01/25 11:39:01 by maldavid ### ########.fr */
/* */
/* ************************************************************************** */
@@ -25,7 +25,7 @@ namespace mlx
_swapChainSupport = querySwapChainSupport(Render_Core::get().getDevice().getPhysicalDevice());
VkSurfaceFormatKHR surfaceFormat = renderer->getSurface().chooseSwapSurfaceFormat(_swapChainSupport.formats);
VkPresentModeKHR presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
VkPresentModeKHR presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR; // change this to set vsync (if the driver supports it)
VkExtent2D extent = chooseSwapExtent(_swapChainSupport.capabilities);
uint32_t imageCount = _swapChainSupport.capabilities.minImageCount + 1;

7
test/main.c
View File

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