Slendi/lunar
1
0
Fork 0
mirror of https://github.com/slendidev/lunar.git synced 2025-12-14 11:49:51 +02:00
Code Issues Packages Projects Releases Wiki Activity

Move to C++ vulkan API

Browse Source 
Signed-off-by: Slendi <slendi@socopon.com>
This commit is contained in:
Slendi
2025-12-11 22:46:55 +02:00
parent c856e0414c
commit 054a196b13
7 changed files with 619 additions and 679 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
meson.build
View File

@@ -71,6 +71,15 @@ add_project_arguments(
'-Wno-switch-enum', '-Wno-switch-enum',
'-Wno-sign-conversion', '-Wno-sign-conversion',
'-Wno-documentation', '-Wno-documentation',
'-Wno-float-equal',
'-Wno-cast-function-type-strict',
'-Wno-exit-time-destructors',
'-Wno-zero-as-null-pointer-constant',
'-Wno-unused-macros',
'-Wno-suggest-override',
'-Wno-macro-redefined',
'-DVULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE',
'-DVULKAN_HPP_DISPATCH_LOADER_DYNAMIC=1',
], ],
language : 'cpp' language : 'cpp'
) )

9
src/GraphicsPipelineBuilder.cpp
View File

@@ -41,10 +41,11 @@ auto GraphicsPipelineBuilder::set_shaders(VkShaderModule vs, VkShaderModule fs)
{ {
m_shader_stages.clear(); m_shader_stages.clear();
m_shader_stages.emplace_back( m_shader_stages.emplace_back(vkinit::pipeline_shader_stage(
vkinit::pipeline_shader_stage(VK_SHADER_STAGE_VERTEX_BIT, vs)); static_cast<vk::ShaderStageFlagBits>(VK_SHADER_STAGE_VERTEX_BIT), vs));
m_shader_stages.emplace_back( m_shader_stages.emplace_back(vkinit::pipeline_shader_stage(
vkinit::pipeline_shader_stage(VK_SHADER_STAGE_FRAGMENT_BIT, fs)); static_cast<vk::ShaderStageFlagBits>(VK_SHADER_STAGE_FRAGMENT_BIT),
fs));
return *this; return *this;
} }

22
src/Types.h
View File

@@ -2,7 +2,7 @@
#include <smath.hpp> #include <smath.hpp>
#include <vk_mem_alloc.h> #include <vk_mem_alloc.h>
#include <vulkan/vulkan_core.h> #include <vulkan/vulkan.hpp>
#include "DeletionQueue.h" #include "DeletionQueue.h"
#include "DescriptorAllocatorGrowable.h" #include "DescriptorAllocatorGrowable.h"
@@ -10,24 +10,24 @@
namespace Lunar { namespace Lunar {
struct AllocatedImage { struct AllocatedImage {
VkImage image; vk::Image image;
VkImageView image_view; vk::ImageView image_view;
VmaAllocation allocation; VmaAllocation allocation;
VkExtent3D extent; vk::Extent3D extent;
VkFormat format; vk::Format format;
}; };
struct AllocatedBuffer { struct AllocatedBuffer {
VkBuffer buffer; vk::Buffer buffer;
VmaAllocation allocation; VmaAllocation allocation;
VmaAllocationInfo info; VmaAllocationInfo info;
}; };
struct FrameData { struct FrameData {
VkCommandPool command_pool; vk::UniqueCommandPool command_pool;
VkCommandBuffer main_command_buffer; vk::UniqueCommandBuffer main_command_buffer;
VkSemaphore swapchain_semaphore; vk::UniqueSemaphore swapchain_semaphore;
VkFence render_fence; vk::UniqueFence render_fence;
DeletionQueue deletion_queue; DeletionQueue deletion_queue;
DescriptorAllocatorGrowable frame_descriptors; DescriptorAllocatorGrowable frame_descriptors;
@@ -43,7 +43,7 @@ struct Vertex {
struct GPUMeshBuffers { struct GPUMeshBuffers {
AllocatedBuffer index_buffer, vertex_buffer; AllocatedBuffer index_buffer, vertex_buffer;
VkDeviceAddress vertex_buffer_address; vk::DeviceAddress vertex_buffer_address;
}; };
struct GPUSceneData { struct GPUSceneData {

224
src/Util.cpp
View File

@@ -4,140 +4,110 @@
namespace vkutil { namespace vkutil {
auto transition_image(VkCommandBuffer cmd, VkImage image, auto transition_image(vk::CommandBuffer cmd, vk::Image image,
VkImageLayout current_layout, VkImageLayout new_layout) -> void vk::ImageLayout current_layout, vk::ImageLayout new_layout) -> void
{ {
VkImageAspectFlags aspect_mask auto aspect_mask = (new_layout == vk::ImageLayout::eDepthAttachmentOptimal)
= (new_layout == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL) ? vk::ImageAspectFlagBits::eDepth
? VK_IMAGE_ASPECT_DEPTH_BIT : vk::ImageAspectFlagBits::eColor;
: VK_IMAGE_ASPECT_COLOR_BIT;
VkImageMemoryBarrier image_barrier { vk::ImageMemoryBarrier image_barrier {};
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, image_barrier.srcAccessMask = vk::AccessFlagBits::eMemoryWrite;
.pNext = nullptr, image_barrier.dstAccessMask
= vk::AccessFlagBits::eMemoryWrite | vk::AccessFlagBits::eMemoryRead;
image_barrier.oldLayout = current_layout;
image_barrier.newLayout = new_layout;
image_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
image_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
image_barrier.image = image;
image_barrier.subresourceRange.aspectMask = aspect_mask;
image_barrier.subresourceRange.baseMipLevel = 0;
image_barrier.subresourceRange.levelCount = 1;
image_barrier.subresourceRange.baseArrayLayer = 0;
image_barrier.subresourceRange.layerCount = 1;
.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT, cmd.pipelineBarrier(vk::PipelineStageFlagBits::eAllCommands,
.dstAccessMask vk::PipelineStageFlagBits::eAllCommands, {}, {}, {}, image_barrier);
= VK_ACCESS_MEMORY_WRITE_BIT | VK_ACCESS_MEMORY_READ_BIT,
.oldLayout = current_layout,
.newLayout = new_layout,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = image,
.subresourceRange = {
.aspectMask = aspect_mask,
.baseMipLevel = 0,
.levelCount = 1,
.baseArrayLayer = 0,
.layerCount = 1,
},
};
vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0, nullptr, 1,
&image_barrier);
} }
auto copy_image_to_image(VkCommandBuffer cmd, VkImage source, auto copy_image_to_image(vk::CommandBuffer cmd, vk::Image source,
VkImage destination, VkExtent2D src_size, VkExtent2D dst_size) -> void vk::Image destination, vk::Extent2D src_size, vk::Extent2D dst_size) -> void
{ {
VkImageBlit2 blit_region {}; vk::ImageBlit2 blit_region {};
blit_region.sType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2; blit_region.srcOffsets[0] = vk::Offset3D { 0, 0, 0 };
blit_region.pNext = nullptr; blit_region.srcOffsets[1]
= vk::Offset3D { static_cast<int32_t>(src_size.width),
static_cast<int32_t>(src_size.height), 1 };
blit_region.srcOffsets[0] = { 0, 0, 0 }; blit_region.dstOffsets[0] = vk::Offset3D { 0, 0, 0 };
blit_region.srcOffsets[1] = { static_cast<int32_t>(src_size.width), blit_region.dstOffsets[1]
static_cast<int32_t>(src_size.height), 1 }; = vk::Offset3D { static_cast<int32_t>(dst_size.width),
static_cast<int32_t>(dst_size.height), 1 };
blit_region.dstOffsets[0] = { 0, 0, 0 }; blit_region.srcSubresource.aspectMask = vk::ImageAspectFlagBits::eColor;
blit_region.dstOffsets[1] = { static_cast<int32_t>(dst_size.width),
static_cast<int32_t>(dst_size.height), 1 };
blit_region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
blit_region.srcSubresource.baseArrayLayer = 0; blit_region.srcSubresource.baseArrayLayer = 0;
blit_region.srcSubresource.layerCount = 1; blit_region.srcSubresource.layerCount = 1;
blit_region.srcSubresource.mipLevel = 0; blit_region.srcSubresource.mipLevel = 0;
blit_region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blit_region.dstSubresource.aspectMask = vk::ImageAspectFlagBits::eColor;
blit_region.dstSubresource.baseArrayLayer = 0; blit_region.dstSubresource.baseArrayLayer = 0;
blit_region.dstSubresource.layerCount = 1; blit_region.dstSubresource.layerCount = 1;
blit_region.dstSubresource.mipLevel = 0; blit_region.dstSubresource.mipLevel = 0;
VkBlitImageInfo2 blit_info {}; vk::BlitImageInfo2 blit_info {};
blit_info.sType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2;
blit_info.pNext = nullptr;
blit_info.dstImage = destination; blit_info.dstImage = destination;
blit_info.dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; blit_info.dstImageLayout = vk::ImageLayout::eTransferDstOptimal;
blit_info.srcImage = source; blit_info.srcImage = source;
blit_info.srcImageLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; blit_info.srcImageLayout = vk::ImageLayout::eTransferSrcOptimal;
blit_info.filter = VK_FILTER_LINEAR; blit_info.filter = vk::Filter::eLinear;
blit_info.regionCount = 1; blit_info.regionCount = 1;
blit_info.pRegions = &blit_region; blit_info.pRegions = &blit_region;
vkCmdBlitImage2(cmd, &blit_info); cmd.blitImage2(blit_info);
} }
auto load_shader_module(std::span<uint8_t> spirv_data, VkDevice device, auto load_shader_module(std::span<uint8_t> spirv_data, vk::Device device)
VkShaderModule *out_shader_module) -> bool -> vk::UniqueShaderModule
{ {
if (!device || !out_shader_module) if (!device || spirv_data.empty() || (spirv_data.size() % 4) != 0) {
return false; return {};
}
if (spirv_data.empty() || (spirv_data.size() % 4) != 0) vk::ShaderModuleCreateInfo create_info {};
return false;
VkShaderModuleCreateInfo create_info {};
create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
create_info.pNext = nullptr;
create_info.flags = 0;
create_info.codeSize = spirv_data.size(); create_info.codeSize = spirv_data.size();
create_info.pCode = reinterpret_cast<uint32_t const *>(spirv_data.data()); create_info.pCode = reinterpret_cast<uint32_t const *>(spirv_data.data());
VkResult const res = vkCreateShaderModule( try {
device, &create_info, nullptr, out_shader_module); return device.createShaderModuleUnique(create_info);
if (res != VK_SUCCESS) { } catch (vk::SystemError const &) {
*out_shader_module = VK_NULL_HANDLE; return {};
return false;
} }
return true;
} }
} // namespace vkutil } // namespace vkutil
namespace vkinit { namespace vkinit {
auto image_create_info(VkFormat format, VkImageUsageFlags usage_flags, auto image_create_info(vk::Format format, vk::ImageUsageFlags usage_flags,
VkExtent3D extent) -> VkImageCreateInfo vk::Extent3D extent) -> vk::ImageCreateInfo
{ {
VkImageCreateInfo info = {}; vk::ImageCreateInfo info {};
info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; info.imageType = vk::ImageType::e2D;
info.pNext = nullptr;
info.imageType = VK_IMAGE_TYPE_2D;
info.format = format; info.format = format;
info.extent = extent; info.extent = extent;
info.mipLevels = 1; info.mipLevels = 1;
info.arrayLayers = 1; info.arrayLayers = 1;
info.samples = vk::SampleCountFlagBits::e1;
info.samples = VK_SAMPLE_COUNT_1_BIT; info.tiling = vk::ImageTiling::eOptimal;
info.tiling = VK_IMAGE_TILING_OPTIMAL;
info.usage = usage_flags; info.usage = usage_flags;
return info; return info;
} }
auto imageview_create_info(VkFormat format, VkImage image, auto imageview_create_info(vk::Format format, vk::Image image,
VkImageAspectFlags aspect_flags) -> VkImageViewCreateInfo vk::ImageAspectFlags aspect_flags) -> vk::ImageViewCreateInfo
{ {
VkImageViewCreateInfo info = {}; vk::ImageViewCreateInfo info {};
info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; info.viewType = vk::ImageViewType::e2D;
info.pNext = nullptr;
info.viewType = VK_IMAGE_VIEW_TYPE_2D;
info.image = image; info.image = image;
info.format = format; info.format = format;
info.subresourceRange.baseMipLevel = 0; info.subresourceRange.baseMipLevel = 0;
@@ -145,27 +115,22 @@ auto imageview_create_info(VkFormat format, VkImage image,
info.subresourceRange.baseArrayLayer = 0; info.subresourceRange.baseArrayLayer = 0;
info.subresourceRange.layerCount = 1; info.subresourceRange.layerCount = 1;
info.subresourceRange.aspectMask = aspect_flags; info.subresourceRange.aspectMask = aspect_flags;
return info; return info;
} }
auto command_buffer_submit_info(VkCommandBuffer cmd) auto command_buffer_submit_info(vk::CommandBuffer cmd)
-> VkCommandBufferSubmitInfo -> vk::CommandBufferSubmitInfo
{ {
VkCommandBufferSubmitInfo info {}; vk::CommandBufferSubmitInfo info {};
info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
info.pNext = nullptr;
info.commandBuffer = cmd; info.commandBuffer = cmd;
info.deviceMask = 0; info.deviceMask = 0;
return info; return info;
} }
auto semaphore_submit_info(VkPipelineStageFlags2 stage_mask, auto semaphore_submit_info(vk::PipelineStageFlags2 stage_mask,
VkSemaphore semaphore) -> VkSemaphoreSubmitInfo vk::Semaphore semaphore) -> vk::SemaphoreSubmitInfo
{ {
VkSemaphoreSubmitInfo info {}; vk::SemaphoreSubmitInfo info {};
info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO;
info.pNext = nullptr;
info.semaphore = semaphore; info.semaphore = semaphore;
info.value = 0; info.value = 0;
info.stageMask = stage_mask; info.stageMask = stage_mask;
@@ -173,14 +138,11 @@ auto semaphore_submit_info(VkPipelineStageFlags2 stage_mask,
return info; return info;
} }
auto submit_info2(VkCommandBufferSubmitInfo *cmd_info, auto submit_info2(vk::CommandBufferSubmitInfo *cmd_info,
VkSemaphoreSubmitInfo *wait_semaphore_info, vk::SemaphoreSubmitInfo *wait_semaphore_info,
VkSemaphoreSubmitInfo *signal_semaphore_info) -> VkSubmitInfo2 vk::SemaphoreSubmitInfo *signal_semaphore_info) -> vk::SubmitInfo2
{ {
VkSubmitInfo2 info {}; vk::SubmitInfo2 info {};
info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2;
info.pNext = nullptr;
info.flags = 0;
info.waitSemaphoreInfoCount = wait_semaphore_info ? 1u : 0u; info.waitSemaphoreInfoCount = wait_semaphore_info ? 1u : 0u;
info.pWaitSemaphoreInfos = wait_semaphore_info; info.pWaitSemaphoreInfos = wait_semaphore_info;
info.commandBufferInfoCount = cmd_info ? 1u : 0u; info.commandBufferInfoCount = cmd_info ? 1u : 0u;
@@ -190,18 +152,15 @@ auto submit_info2(VkCommandBufferSubmitInfo *cmd_info,
return info; return info;
} }
auto attachment_info(VkImageView view, VkClearValue *clear, auto attachment_info(vk::ImageView view, vk::ClearValue *clear,
VkImageLayout layout) -> VkRenderingAttachmentInfo vk::ImageLayout layout) -> vk::RenderingAttachmentInfo
{ {
VkRenderingAttachmentInfo color_at {}; vk::RenderingAttachmentInfo color_at {};
color_at.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
color_at.pNext = nullptr;
color_at.imageView = view; color_at.imageView = view;
color_at.imageLayout = layout; color_at.imageLayout = layout;
color_at.loadOp color_at.loadOp
= clear ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD; = clear ? vk::AttachmentLoadOp::eClear : vk::AttachmentLoadOp::eLoad;
color_at.storeOp = VK_ATTACHMENT_STORE_OP_STORE; color_at.storeOp = vk::AttachmentStoreOp::eStore;
if (clear) { if (clear) {
color_at.clearValue = *clear; color_at.clearValue = *clear;
} }
@@ -209,27 +168,22 @@ auto attachment_info(VkImageView view, VkClearValue *clear,
return color_at; return color_at;
} }
auto pipeline_shader_stage(VkShaderStageFlagBits stage, VkShaderModule module) auto pipeline_shader_stage(vk::ShaderStageFlagBits stage,
-> VkPipelineShaderStageCreateInfo vk::ShaderModule module) -> vk::PipelineShaderStageCreateInfo
{ {
VkPipelineShaderStageCreateInfo stage_ci {}; vk::PipelineShaderStageCreateInfo stage_ci {};
stage_ci.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stage_ci.pNext = nullptr;
stage_ci.stage = stage; stage_ci.stage = stage;
stage_ci.module = module; stage_ci.module = module;
stage_ci.pName = "main"; stage_ci.pName = "main";
return stage_ci; return stage_ci;
} }
auto render_info(VkExtent2D extent, VkRenderingAttachmentInfo const *color_att, auto render_info(vk::Extent2D extent,
VkRenderingAttachmentInfo const *depth_att) -> VkRenderingInfo vk::RenderingAttachmentInfo const *color_att,
vk::RenderingAttachmentInfo const *depth_att) -> vk::RenderingInfo
{ {
vk::RenderingInfo render_info {};
VkRenderingInfo render_info {}; render_info.renderArea = vk::Rect2D { {}, extent };
render_info.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
render_info.pNext = nullptr;
render_info.flags = 0;
render_info.renderArea = { {}, extent };
render_info.layerCount = 1; render_info.layerCount = 1;
render_info.colorAttachmentCount = color_att ? 1 : 0; render_info.colorAttachmentCount = color_att ? 1 : 0;
render_info.pColorAttachments = color_att; render_info.pColorAttachments = color_att;
@@ -237,19 +191,15 @@ auto render_info(VkExtent2D extent, VkRenderingAttachmentInfo const *color_att,
return render_info; return render_info;
} }
auto depth_attachment_info(VkImageView view, VkImageLayout layout) auto depth_attachment_info(vk::ImageView view, vk::ImageLayout layout)
-> VkRenderingAttachmentInfo -> vk::RenderingAttachmentInfo
{ {
VkRenderingAttachmentInfo depth_att {}; vk::RenderingAttachmentInfo depth_att {};
depth_att.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
depth_att.pNext = nullptr;
depth_att.imageView = view; depth_att.imageView = view;
depth_att.imageLayout = layout; depth_att.imageLayout = layout;
depth_att.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; depth_att.loadOp = vk::AttachmentLoadOp::eClear;
depth_att.storeOp = VK_ATTACHMENT_STORE_OP_STORE; depth_att.storeOp = vk::AttachmentStoreOp::eStore;
depth_att.clearValue.depthStencil.depth = 1.f; depth_att.clearValue.depthStencil.depth = 1.f;
return depth_att; return depth_att;
} }

65
src/Util.h
View File

@@ -3,7 +3,7 @@
#include <span> #include <span>
#include <vulkan/vk_enum_string_helper.h> #include <vulkan/vk_enum_string_helper.h>
#include <vulkan/vulkan.h> #include <vulkan/vulkan.hpp>
template<typename F> struct privDefer { template<typename F> struct privDefer {
F f; F f;
@@ -29,46 +29,49 @@ template<typename F> privDefer<F> defer_func(F f) { return privDefer<F>(f); }
#define VK_CHECK(logger, x) \ #define VK_CHECK(logger, x) \
do { \ do { \
VkResult err { x }; \ auto err { x }; \
if (err) { \ auto result = vk::Result(err); \
(logger).err("Detected Vulkan error: {}", string_VkResult(err)); \ if (result != vk::Result::eSuccess) { \
(logger).err("Detected Vulkan error: {}", vk::to_string(result)); \
throw std::runtime_error("Vulkan error"); \ throw std::runtime_error("Vulkan error"); \
} \ } \
} while (0) } while (0)
namespace vkutil { namespace vkutil {
auto transition_image(VkCommandBuffer cmd, VkImage image, auto transition_image(vk::CommandBuffer cmd, vk::Image image,
VkImageLayout current_layout, VkImageLayout new_layout) -> void; vk::ImageLayout current_layout, vk::ImageLayout new_layout) -> void;
auto copy_image_to_image(VkCommandBuffer cmd, VkImage source, auto copy_image_to_image(vk::CommandBuffer cmd, vk::Image source,
VkImage destination, VkExtent2D src_size, VkExtent2D dst_size) -> void; vk::Image destination, vk::Extent2D src_size, vk::Extent2D dst_size)
auto load_shader_module(std::span<uint8_t> spirv_data, VkDevice device, -> void;
VkShaderModule *out_shader_module) -> bool; auto load_shader_module(std::span<uint8_t> spirv_data, vk::Device device)
-> vk::UniqueShaderModule;
} // namespace vkutil } // namespace vkutil
namespace vkinit { namespace vkinit {
auto image_create_info(VkFormat format, VkImageUsageFlags usage_flags, auto image_create_info(vk::Format format, vk::ImageUsageFlags usage_flags,
VkExtent3D extent) -> VkImageCreateInfo; vk::Extent3D extent) -> vk::ImageCreateInfo;
auto imageview_create_info(VkFormat format, VkImage image, auto imageview_create_info(vk::Format format, vk::Image image,
VkImageAspectFlags aspect_flags) -> VkImageViewCreateInfo; vk::ImageAspectFlags aspect_flags) -> vk::ImageViewCreateInfo;
auto command_buffer_submit_info(VkCommandBuffer cmd) auto command_buffer_submit_info(vk::CommandBuffer cmd)
-> VkCommandBufferSubmitInfo; -> vk::CommandBufferSubmitInfo;
auto semaphore_submit_info(VkPipelineStageFlags2 stage_mask, auto semaphore_submit_info(vk::PipelineStageFlags2 stage_mask,
VkSemaphore semaphore) -> VkSemaphoreSubmitInfo; vk::Semaphore semaphore) -> vk::SemaphoreSubmitInfo;
auto submit_info2(VkCommandBufferSubmitInfo *cmd_info, auto submit_info2(vk::CommandBufferSubmitInfo *cmd_info,
VkSemaphoreSubmitInfo *wait_semaphore_info, vk::SemaphoreSubmitInfo *wait_semaphore_info,
VkSemaphoreSubmitInfo *signal_semaphore_info) -> VkSubmitInfo2; vk::SemaphoreSubmitInfo *signal_semaphore_info) -> vk::SubmitInfo2;
auto attachment_info(VkImageView view, VkClearValue *clear, auto attachment_info(vk::ImageView view, vk::ClearValue *clear,
VkImageLayout layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) vk::ImageLayout layout = vk::ImageLayout::eColorAttachmentOptimal)
-> VkRenderingAttachmentInfo; -> vk::RenderingAttachmentInfo;
auto pipeline_shader_stage(VkShaderStageFlagBits stage, VkShaderModule module) auto pipeline_shader_stage(vk::ShaderStageFlagBits stage,
-> VkPipelineShaderStageCreateInfo; vk::ShaderModule module) -> vk::PipelineShaderStageCreateInfo;
auto render_info(VkExtent2D extent, VkRenderingAttachmentInfo const *color_att, auto render_info(vk::Extent2D extent,
VkRenderingAttachmentInfo const *depth_att) -> VkRenderingInfo; vk::RenderingAttachmentInfo const *color_att,
auto depth_attachment_info(VkImageView view, vk::RenderingAttachmentInfo const *depth_att) -> vk::RenderingInfo;
VkImageLayout layout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL) auto depth_attachment_info(vk::ImageView view,
-> VkRenderingAttachmentInfo; vk::ImageLayout layout = vk::ImageLayout::eDepthAttachmentOptimal)
-> vk::RenderingAttachmentInfo;
} // namespace vkinit } // namespace vkinit

892
src/VulkanRenderer.cpp
View File

File diff suppressed because it is too large Load Diff

77
src/VulkanRenderer.h
View File

@@ -7,7 +7,7 @@
#include <VkBootstrap.h> #include <VkBootstrap.h>
#include <smath.hpp> #include <smath.hpp>
#include <vk_mem_alloc.h> #include <vk_mem_alloc.h>
#include <vulkan/vulkan_core.h> #include <vulkan/vulkan.hpp>
#include "DeletionQueue.h" #include "DeletionQueue.h"
#include "DescriptorAllocator.h" #include "DescriptorAllocator.h"
@@ -19,7 +19,7 @@ namespace Lunar {
struct GPUDrawPushConstants { struct GPUDrawPushConstants {
smath::Mat4 world_matrix; smath::Mat4 world_matrix;
VkDeviceAddress vertex_buffer; vk::DeviceAddress vertex_buffer;
}; };
constexpr unsigned FRAME_OVERLAP = 2; constexpr unsigned FRAME_OVERLAP = 2;
@@ -31,7 +31,7 @@ struct VulkanRenderer {
auto render() -> void; auto render() -> void;
auto resize(uint32_t width, uint32_t height) -> void; auto resize(uint32_t width, uint32_t height) -> void;
auto immediate_submit(std::function<void(VkCommandBuffer cmd)> &&function) auto immediate_submit(std::function<void(vk::CommandBuffer cmd)> &&function)
-> void; -> void;
auto upload_mesh(std::span<uint32_t> indices, std::span<Vertex> vertices) auto upload_mesh(std::span<uint32_t> indices, std::span<Vertex> vertices)
-> GPUMeshBuffers; -> GPUMeshBuffers;
@@ -51,9 +51,10 @@ private:
auto imgui_init() -> void; auto imgui_init() -> void;
auto default_data_init() -> void; auto default_data_init() -> void;
auto draw_background(VkCommandBuffer cmd) -> void; auto draw_background(vk::CommandBuffer cmd) -> void;
auto draw_geometry(VkCommandBuffer cmd) -> void; auto draw_geometry(vk::CommandBuffer cmd) -> void;
auto draw_imgui(VkCommandBuffer cmd, VkImageView target_image_view) -> void; auto draw_imgui(vk::CommandBuffer cmd, vk::ImageView target_image_view)
-> void;
auto create_swapchain(uint32_t width, uint32_t height) -> void; auto create_swapchain(uint32_t width, uint32_t height) -> void;
auto create_draw_image(uint32_t width, uint32_t height) -> void; auto create_draw_image(uint32_t width, uint32_t height) -> void;
@@ -63,16 +64,20 @@ private:
auto destroy_depth_image() -> void; auto destroy_depth_image() -> void;
auto recreate_swapchain(uint32_t width, uint32_t height) -> void; auto recreate_swapchain(uint32_t width, uint32_t height) -> void;
auto destroy_swapchain() -> void; auto destroy_swapchain() -> void;
auto create_image(VkExtent3D size, VkFormat format, VkImageUsageFlags flags, auto create_image(vk::Extent3D size, vk::Format format,
bool mipmapped = false) -> AllocatedImage; vk::ImageUsageFlags flags, bool mipmapped = false) -> AllocatedImage;
auto create_image(void const *data, VkExtent3D size, VkFormat format, auto create_image(void const *data, vk::Extent3D size, vk::Format format,
VkImageUsageFlags flags, bool mipmapped = false) -> AllocatedImage; vk::ImageUsageFlags flags, bool mipmapped = false) -> AllocatedImage;
auto destroy_image(AllocatedImage const &img) -> void; auto destroy_image(AllocatedImage const &img) -> void;
auto create_buffer(size_t alloc_size, VkBufferUsageFlags usage, auto create_buffer(size_t alloc_size, vk::BufferUsageFlags usage,
VmaMemoryUsage memory_usage) -> AllocatedBuffer; VmaMemoryUsage memory_usage) -> AllocatedBuffer;
auto destroy_buffer(AllocatedBuffer const &buffer) -> void; auto destroy_buffer(AllocatedBuffer const &buffer) -> void;
vk::Instance m_instance {};
vk::PhysicalDevice m_physical_device {};
vk::Device m_device {};
struct { struct {
vkb::Instance instance; vkb::Instance instance;
vkb::PhysicalDevice phys_dev; vkb::PhysicalDevice phys_dev;
@@ -86,52 +91,52 @@ private:
return frames.at(frame_number % frames.size()); return frames.at(frame_number % frames.size());
} }
VkSwapchainKHR swapchain { VK_NULL_HANDLE }; vk::SwapchainKHR swapchain {};
VkSurfaceKHR surface { nullptr }; vk::SurfaceKHR surface {};
VkFormat swapchain_image_format; vk::Format swapchain_image_format {};
uint32_t graphics_queue_family { 0 }; uint32_t graphics_queue_family { 0 };
VkQueue graphics_queue { nullptr }; vk::Queue graphics_queue {};
std::vector<VkImage> swapchain_images; std::vector<vk::Image> swapchain_images;
std::vector<VkImageView> swapchain_image_views; std::vector<vk::UniqueImageView> swapchain_image_views;
std::vector<VkSemaphore> present_semaphores; std::vector<vk::UniqueSemaphore> present_semaphores;
VkExtent2D swapchain_extent; vk::Extent2D swapchain_extent;
std::array<FrameData, FRAME_OVERLAP> frames; std::array<FrameData, FRAME_OVERLAP> frames;
AllocatedImage draw_image {}; AllocatedImage draw_image {};
AllocatedImage depth_image {}; AllocatedImage depth_image {};
VkExtent2D draw_extent {}; vk::Extent2D draw_extent {};
VmaAllocator allocator; VmaAllocator allocator;
DescriptorAllocator descriptor_allocator; DescriptorAllocator descriptor_allocator;
VkDescriptorSet draw_image_descriptors; VkDescriptorSet draw_image_descriptors {};
VkDescriptorSetLayout draw_image_descriptor_layout; vk::DescriptorSetLayout draw_image_descriptor_layout {};
GPUSceneData scene_data {}; GPUSceneData scene_data {};
VkDescriptorSetLayout gpu_scene_data_descriptor_layout; vk::DescriptorSetLayout gpu_scene_data_descriptor_layout {};
VkDescriptorSetLayout single_image_descriptor_layout; vk::DescriptorSetLayout single_image_descriptor_layout {};
VkPipeline gradient_pipeline {}; vk::UniquePipeline gradient_pipeline;
VkPipelineLayout gradient_pipeline_layout {}; vk::UniquePipelineLayout gradient_pipeline_layout;
VkPipeline triangle_pipeline {}; vk::Pipeline triangle_pipeline {};
VkPipelineLayout triangle_pipeline_layout {}; vk::UniquePipelineLayout triangle_pipeline_layout;
VkPipeline mesh_pipeline {}; vk::Pipeline mesh_pipeline {};
VkPipelineLayout mesh_pipeline_layout {}; vk::UniquePipelineLayout mesh_pipeline_layout;
GPUMeshBuffers rectangle; GPUMeshBuffers rectangle;
VkDescriptorPool imgui_descriptor_pool { VK_NULL_HANDLE }; vk::UniqueDescriptorPool imgui_descriptor_pool;
DeletionQueue deletion_queue; DeletionQueue deletion_queue;
VkFence imm_fence {}; vk::UniqueFence imm_fence;
VkCommandBuffer imm_command_buffer {}; vk::UniqueCommandBuffer imm_command_buffer;
VkCommandPool imm_command_pool {}; vk::UniqueCommandPool imm_command_pool;
uint64_t frame_number { 0 }; uint64_t frame_number { 0 };
@@ -142,8 +147,8 @@ private:
AllocatedImage gray_image {}; AllocatedImage gray_image {};
AllocatedImage error_image {}; AllocatedImage error_image {};
VkSampler default_sampler_linear; vk::UniqueSampler default_sampler_linear;
VkSampler default_sampler_nearest; vk::UniqueSampler default_sampler_nearest;
} m_vk; } m_vk;
SDL_Window *m_window { nullptr }; SDL_Window *m_window { nullptr };