Move to C++ vulkan API

Signed-off-by: Slendi <slendi@socopon.com>

meson.build

@@ -71,6 +71,15 @@ add_project_arguments(
 		'-Wno-switch-enum',
 		'-Wno-sign-conversion',
 		'-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'
 )

src/GraphicsPipelineBuilder.cpp

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

src/Types.h

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

src/Util.cpp

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

src/Util.h

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

src/VulkanRenderer.h

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