Implement GPU command wrappers

src/gpu/gpu.h

@@ -215,13 +215,13 @@ typedef enum GpuImageType {
 } GpuImageType;
 
 typedef enum GpuSampleCount {
-	GPU_SAMPLE_COUNT_1_BIT,
+	GPU_SAMPLE_COUNT_1,
-	GPU_SAMPLE_COUNT_2_BIT,
+	GPU_SAMPLE_COUNT_2,
-	GPU_SAMPLE_COUNT_4_BIT,
+	GPU_SAMPLE_COUNT_4,
-	GPU_SAMPLE_COUNT_8_BIT,
+	GPU_SAMPLE_COUNT_8,
-	GPU_SAMPLE_COUNT_16_BIT,
+	GPU_SAMPLE_COUNT_16,
-	GPU_SAMPLE_COUNT_32_BIT,
+	GPU_SAMPLE_COUNT_32,
-	GPU_SAMPLE_COUNT_64_BIT,
+	GPU_SAMPLE_COUNT_64,
 } GpuSampleCount;
 
 typedef enum GpuImageTiling {
@@ -277,9 +277,9 @@ typedef enum GpuImageLayout {
 
 typedef enum GpuImageAspect {
 	GPU_IMAGE_ASPECT_NONE     = 0,
-	GPU_IMAGE_ASPECT_COLOR_BIT    = 1 << 0,
+	GPU_IMAGE_ASPECT_COLOR    = 1 << 0,
-	GPU_IMAGE_ASPECT_DEPTH_BIT    = 1 << 1,
+	GPU_IMAGE_ASPECT_DEPTH    = 1 << 1,
-	GPU_IMAGE_ASPECT_STENCIL_BIT  = 1 << 2,
+	GPU_IMAGE_ASPECT_STENCIL  = 1 << 2,
 } GpuImageAspect;
 
 typedef struct GpuImageSubresourceRange {
@@ -339,6 +339,7 @@ typedef struct GpuBuffer {
 	u64                gpu_device_address;
 	u64                size;
 } GpuBuffer;
+typedef GpuBuffer *GpuBufferArray;
 
 typedef struct GpuBufferCreateRequest {
 	GpuDevice     *device;
@@ -350,6 +351,13 @@ typedef struct GpuFence GpuFence;
 
 typedef struct GpuSemaphore GpuSemaphore;
 
+typedef struct GpuSwapchainAcquireImageRequest {
+	GpuSwapchain *swapchain;
+	GpuSemaphore *semaphore;
+	GpuFence     *fence;
+	u64           timeout;
+} GpuSwapchainAcquireImageRequest;
+
 typedef struct GpuCommandPool GpuCommandPool;
 
 typedef struct GpuCommandBuffer GpuCommandBuffer;
@@ -450,40 +458,15 @@ wp_intern const GpuAccessFlagsBits GPU_ACCESS_MICROMAP_WRITE
 wp_intern const GpuAccessFlagsBits GPU_ACCESS_MEMORY_DECOMPRESSION_READ             = wpU64Const(1) << 42;
 wp_intern const GpuAccessFlagsBits GPU_ACCESS_MEMORY_DECOMPRESSION_WRITE            = wpU64Const(1) << 43;
 
-typedef struct GpuMemoryBarrier {
+typedef struct GpuCommandBufferBeginRequest {
-	GpuPipelineStageFlags    src_stage_mask;
+	GpuCommandBuffer *command_buffer;
-	GpuPipelineStageFlags    dst_stage_mask;
+	b32               one_time_submit;
-	GpuAccessFlags           src_access_mask;
+} GpuCommandBufferBeginRequest;
-	GpuAccessFlags           dst_access_mask;
-} GpuMemoryBarrier;
-
-typedef struct GpuBufferMemoryBarrier {
-	GpuBuffer               *buffer;
-	GpuPipelineStageFlags    src_stage_mask;
-	GpuPipelineStageFlags    dst_stage_mask;
-	GpuAccessFlags           src_access_mask;
-	GpuAccessFlags           dst_access_mask;
-	u32                      src_queue_family_index;
-	u32                      dst_queue_family_index;
-} GpuBufferMemoryBarrier;
-
-typedef struct GpuImageMemoryBarrier {
-	GpuImageSubresourceRange subresource;
-	GpuImage                *image;
-	GpuPipelineStageFlags    src_stage_mask;
-	GpuPipelineStageFlags    dst_stage_mask;
-	GpuAccessFlags           src_access_mask;
-	GpuAccessFlags           dst_access_mask;
-	GpuImageLayout           old_layout;
-	GpuImageLayout           new_layout;
-	u32                      src_queue_family_index;
-	u32                      dst_queue_family_index;
-} GpuImageMemoryBarrier;
 
 typedef struct GpuCommandBuffersSubmitRequest {
 	GpuDevice               *device;
 	GpuFence                *fence;
-	GpuCommandBufferPtrArray buffers;
+	GpuCommandBufferPtrArray command_buffers;
 } GpuCommandBuffersSubmitRequest;
 
 typedef enum GpuDescriptorType {
@@ -890,6 +873,200 @@ typedef struct GpuComputePipelinesCreateRequest {
 	GpuComputePipelineCreateInfoArray infos;
 } GpuComputePipelinesCreateRequest;
 
+typedef struct GpuMemoryBarrier {
+	GpuPipelineStageFlags    src_stage_mask;
+	GpuPipelineStageFlags    dst_stage_mask;
+	GpuAccessFlags           src_access_mask;
+	GpuAccessFlags           dst_access_mask;
+} GpuMemoryBarrier;
+typedef GpuMemoryBarrier *GpuMemoryBarrierArray;
+
+typedef struct GpuBufferMemoryBarrier {
+	GpuBuffer               *buffer;
+	GpuPipelineStageFlags    src_stage_mask;
+	GpuPipelineStageFlags    dst_stage_mask;
+	GpuAccessFlags           src_access_mask;
+	GpuAccessFlags           dst_access_mask;
+	u64                      offset;
+	u32                      src_queue_family_index;
+	u32                      dst_queue_family_index;
+} GpuBufferMemoryBarrier;
+typedef GpuBufferMemoryBarrier *GpuBufferMemoryBarrierArray;
+
+typedef struct GpuImageMemoryBarrier {
+	GpuImageSubresourceRange subresource;
+	GpuImage                *image;
+	GpuPipelineStageFlags    src_stage_mask;
+	GpuPipelineStageFlags    dst_stage_mask;
+	GpuAccessFlags           src_access_mask;
+	GpuAccessFlags           dst_access_mask;
+	GpuImageLayout           old_layout;
+	GpuImageLayout           new_layout;
+	u32                      src_queue_family_index;
+	u32                      dst_queue_family_index;
+} GpuImageMemoryBarrier;
+typedef GpuImageMemoryBarrier *GpuImageMemoryBarrierArray;
+
+typedef struct GpuDependencyInfo {
+	GpuMemoryBarrierArray       memory_barriers;
+	GpuImageMemoryBarrierArray  image_memory_barriers;
+	GpuBufferMemoryBarrierArray buffer_memory_barriers;
+} GpuDependencyInfo;
+
+typedef struct GpuCmdPipelineBarrierRequest {
+	GpuCommandBuffer *command_buffer;
+	GpuDependencyInfo info;
+} GpuCmdPipelineBarrierRequest;
+
+typedef struct GpuClearColorValue {
+	union {
+		f32 raw[4];
+		struct {
+			f32 r;
+			f32 g;
+			f32 b;
+			f32 a;
+		} rgba;
+	};
+} GpuClearColorValue;
+
+typedef struct GpuClearDepthStencilValue {
+	f32 depth;
+	u32 stencil;
+} GpuClearDepthStencilValue;
+
+typedef union GpuClearValue {
+	GpuClearColorValue        color;
+	GpuClearDepthStencilValue depth_stencil;
+} GpuClearValue;
+
+typedef enum GpuResolveModeFlags {
+	GPU_RESOLVE_MODE_NONE        = 0,
+	GPU_RESOLVE_MODE_SAMPLE_ZERO = wpU64Const(1) << 0,
+	GPU_RESOLVE_MODE_AVERAGE     = wpU64Const(1) << 1,
+	GPU_RESOLVE_MODE_MIN         = wpU64Const(1) << 2,
+	GPU_RESOLVE_MODE_MAX         = wpU64Const(1) << 3,
+} GpuResolveModeFlags;
+
+typedef enum GpuAttachmentLoadOp {
+	GPU_ATTACHMENT_LOAD_OP_LOAD,
+	GPU_ATTACHMENT_LOAD_OP_CLEAR,
+	GPU_ATTACHMENT_LOAD_OP_DONT_CARE,
+	GPU_ATTACHMENT_LOAD_OP_NONE,
+} GpuAttachmentLoadOp;
+
+typedef enum GpuAttachmentStoreOp {
+	GPU_ATTACHMENT_STORE_OP_STORE,
+	GPU_ATTACHMENT_STORE_OP_DONT_CARE,
+	GPU_ATTACHMENT_STORE_OP_NONE,
+} GpuAttachmentStoreOp;
+
+typedef struct GpuRenderingAttachmentInfo {
+	GpuImage            *image;
+	GpuImageLayout       layout;
+	GpuResolveModeFlags  resolve_mode;
+	GpuImage            *resolve_image;
+	GpuImageLayout       resolve_image_layout;
+	GpuAttachmentLoadOp  load_op;
+	GpuAttachmentStoreOp store_op;
+	GpuClearValue        clear_value;
+} GpuRenderingAttachmentInfo;
+typedef GpuRenderingAttachmentInfo *GpuRenderingAttachmentInfoArray;
+
+typedef struct GpuCmdBeginRenderingRequest {
+	GpuRect2d                       render_area;
+	GpuRenderingAttachmentInfoArray color_attachments;
+	GpuRenderingAttachmentInfo     *depth_attachment;
+	GpuRenderingAttachmentInfo     *stencil_attachment;
+	u64                             layer_count;
+	u64                             view_mask;
+	GpuCommandBuffer               *command_buffer;
+} GpuCmdBeginRenderingRequest;
+
+typedef struct GpuCmdSetViewportRequest {
+	GpuCommandBuffer *command_buffer;
+	GpuViewportArray  viewports;
+} GpuCmdSetViewportRequest;
+
+typedef struct GpuCmdSetScissorRequest {
+	GpuCommandBuffer *command_buffer;
+	GpuRect2dArray    scissors;
+} GpuCmdSetScissorRequest;
+
+typedef enum GpuPipelineBindPoint {
+	GPU_PIPELINE_BIND_POINT_GRAPHICS,
+	GPU_PIPELINE_BIND_POINT_COMPUTE,
+	GPU_PIPELINE_BIND_POINT_RAY_TRACING,
+} GpuPipelineBindPoint;
+
+typedef struct GpuCmdBindPipelineRequest {
+	GpuCommandBuffer    *command_buffer;
+	GpuPipeline         *pipeline;
+	GpuPipelineBindPoint bind_point;
+} GpuCmdBindPipelineRequest;
+
+typedef struct GpuCmdBindDescriptorSetsRequest {
+	GpuCommandBuffer        *command_buffer;
+	GpuPipelineLayout       *layout;
+	GpuDescriptorSetPtrArray sets;
+	GpuPipelineBindPoint     bind_point;
+} GpuCmdBindDescriptorSetsRequest;
+
+typedef struct GpuCmdBindVertexBuffersRequest {
+	GpuCommandBuffer *command_buffer;
+	GpuBufferArray    vertex_buffers;
+	WpU64Array        offsets;
+} GpuCmdBindVertexBuffersRequest;
+
+typedef enum GpuIndexType {
+	GPU_INDEX_TYPE_NONE,
+	GPU_INDEX_TYPE_UINT16,
+	GPU_INDEX_TYPE_UINT32,
+	GPU_INDEX_TYPE_UINT8,
+} GpuIndexType;
+
+typedef struct GpuCmdBindIndexBufferRequest {
+	GpuBuffer         index_buffer;
+	GpuCommandBuffer *command_buffer;
+	u64               offset;
+	GpuIndexType      index_type;
+} GpuCmdBindIndexBufferRequest;
+
+typedef struct GpuCmdPushConstantsRequest {
+	GpuCommandBuffer  *command_buffer;
+	GpuPipelineLayout *layout;
+	GpuShaderStage     stage_flags;
+	void              *values;
+	u32                offset;
+	u32                total_size_in_bytes;
+} GpuCmdPushConstantsRequest;
+
+typedef struct GpuCmdDrawIndexedRequest {
+	GpuCommandBuffer *command_buffer;
+	u32               index_count;
+	u32               instance_count;
+	u32               first_index;
+	i32               vertex_offset;
+	u32               first_instance;
+} GpuCmdDrawIndexedRequest;
+
+typedef struct GpuCmdDispatchRequest {
+	GpuCommandBuffer *command_buffer;
+	u32               group_count_x;
+	u32               group_count_y;
+	u32               group_count_z;
+} GpuCmdDispatchRequest;
+
+typedef struct GpuCmdDispatchBaseRequest {
+	GpuCommandBuffer *command_buffer;
+	u32               base_group_x;
+	u32               base_group_y;
+	u32               base_group_z;
+	u32               group_count_x;
+	u32               group_count_y;
+	u32               group_count_z;
+} GpuCmdDispatchBaseRequest;
+
 GpuInstance             *gpuInit(const WpAllocator *allocator, GpuInitRequest request);
 GpuPhysicalDevice        gpuFindPhysicalDevice(const WpAllocator *allocator, const WpAllocator *temp,
                                                GpuPhysicalDeviceFindRequest request);
@@ -903,6 +1080,7 @@ void                     gpuDestroySwapchain(GpuSwapchain *swapchain);
 u64                      gpuGetSwapchainImageCount(GpuSwapchain *swapchain);
 GpuFormat                gpuGetSwapchainImageFormat(GpuSwapchain *swapchain);
 GpuFormat                gpuGetSwapchainDepthFormat(GpuSwapchain *swapchain);
+u64                      gpuAcquireNextSwapchainImage(GpuSwapchainAcquireImageRequest request);
 GpuSampler              *gpuCreateSampler(const WpAllocator *allocator, GpuSamplerCreateRequest request);
 void                     gpuDestroySampler(GpuSampler *sampler);
 GpuImage                *gpuCreateImage(const WpAllocator *allocator, GpuImageCreateRequest request);
@@ -920,7 +1098,7 @@ void                     gpuDestroyCommandPool(GpuCommandPool *pool);
 void                     gpuResetCommandPool(GpuCommandPool *pool);
 GpuCommandBufferPtrArray gpuAllocateCommandBuffers(const WpAllocator *allocator, const WpAllocator *temp,
                                                    GpuCommandBufferAllocateRequest request);
-void                     gpuBeginCommandBuffer(GpuCommandBuffer *buffer);
+void                     gpuBeginCommandBuffer(GpuCommandBufferBeginRequest request);
 void                     gpuEndCommandBuffer(GpuCommandBuffer *buffer);
 void                     gpuSubmitCommandBuffers(const WpAllocator *temp, GpuCommandBuffersSubmitRequest request);
 void                     gpuResetCommandBuffer(GpuCommandBuffer *buffer);
@@ -945,6 +1123,21 @@ GpuPipelinePtrArray      gpuCreateComputePipelines(const WpAllocator *allocator,
 void                     gpuDestroyPipeline(GpuPipeline *pipeline);
 void                     gpuDeviceWaitIdle(GpuDevice *device);
 
+// COMMANDS
+void                     gpuCmdPipelineBarrier(const WpAllocator *temp, GpuCmdPipelineBarrierRequest request);
+void                     gpuCmdBeginRendering(const WpAllocator *temp, GpuCmdBeginRenderingRequest request);
+void                     gpuCmdEndRendering(GpuCommandBuffer *buffer);
+void                     gpuCmdSetViewport(const WpAllocator *temp, GpuCmdSetViewportRequest request);
+void                     gpuCmdSetScissor(const WpAllocator *temp, GpuCmdSetScissorRequest request);
+void                     gpuCmdBindPipeline(GpuCmdBindPipelineRequest request);
+void                     gpuCmdBindDescriptorSets(const WpAllocator *temp, GpuCmdBindDescriptorSetsRequest request);
+void                     gpuCmdBindVertexBuffers(const WpAllocator *temp, GpuCmdBindVertexBuffersRequest request);
+void                     gpuCmdBindIndexBuffer(GpuCmdBindIndexBufferRequest request);
+void                     gpuCmdPushConstants(GpuCmdPushConstantsRequest request);
+void                     gpuCmdDrawIndexed(GpuCmdDrawIndexedRequest request);
+void                     gpuCmdDispatch(GpuCmdDispatchRequest request);
+void                     gpuCmdDispatchBase(GpuCmdDispatchBaseRequest request);
+
 #ifdef WP_PLATFORM_CPP
 END_C_LINKAGE
 #endif

src/gpu/vulkan/vk_gpu.c

@@ -27,6 +27,7 @@ wp_intern WpLogger logger = wpLogMakeLogger(wpStr8LitRo("Vulkan Wrapper"));
 
 typedef VkPhysicalDevice                                   *VkPhysicalDeviceArray;
 typedef VkQueueFamilyProperties2                           *VkQueueFamilyProperties2Array;
+typedef VkBuffer                                           *VkBufferArray;
 typedef VkImage                                            *VkImageArray;
 typedef VkImageView                                        *VkImageViewArray;
 typedef VkFormat                                           *VkFormatArray;
@@ -62,6 +63,10 @@ typedef VkPipelineDepthStencilStateCreateInfo              *VkPipelineDepthStenc
 typedef VkPipelineColorBlendStateCreateInfo                *VkPipelineColorBlendStateCreateInfoArray;
 typedef VkPipelineRenderingCreateInfo                      *VkPipelineRenderingCreateInfoArray;
 typedef VkDynamicState                                     *VkDynamicStateArray;
+typedef VkMemoryBarrier2                                   *VkMemoryBarrier2Array;
+typedef VkBufferMemoryBarrier2                             *VkBufferMemoryBarrier2Array;
+typedef VkImageMemoryBarrier2                              *VkImageMemoryBarrier2Array;
+typedef VkRenderingAttachmentInfo                          *VkRenderingAttachmentInfoArray;
 
 struct GpuInstance {
 	VkInstance          vk_instance;
@@ -290,6 +295,16 @@ wp_intern VkColorComponentFlags        vkColorComponentFlagsFromGpuColorComponen
 wp_intern GpuColorComponentFlags       gpuColorComponentFlagsFromVkColorComponentFlags(VkColorComponentFlags flags);
 wp_intern VkLogicOp                    vkLogicOpFromGpuLogicOp(GpuLogicOp op);
 wp_intern GpuLogicOp                   gpuLogicOpFromVkLogicOp(VkLogicOp op);
+wp_intern VkPipelineBindPoint          vkPipelineBindPointFromGpuPipelineBindPoint(GpuPipelineBindPoint binding);
+wp_intern GpuPipelineBindPoint         gpuPipelineBindPointFromVkPipelineBindPoint(VkPipelineBindPoint binding);
+wp_intern VkIndexType                  vkIndexTypeFromGpuIndexType(GpuIndexType type);
+wp_intern GpuIndexType                 gpuIndexTypeFromVkIndexType(VkIndexType type);
+wp_intern VkAttachmentLoadOp           vkAttachmentLoadOpFromGpuAttachmentLoadOp(GpuAttachmentLoadOp op);
+wp_intern GpuAttachmentLoadOp          gpuAttachmentLoadOpFromVkAttachmentLoadOp(VkAttachmentLoadOp op);
+wp_intern VkAttachmentStoreOp          vkAttachmentStoreOpFromGpuAttachmentStoreOp(GpuAttachmentStoreOp op);
+wp_intern GpuAttachmentStoreOp         gpuAttachmentStoreOpFromVkAttachmentStoreOp(VkAttachmentStoreOp op);
+wp_intern VkResolveModeFlagBits        vkResolveModeFlagsFromGpuResolveModeFlags(GpuResolveModeFlags flags);
+wp_intern GpuResolveModeFlags          gpuResolveModeFlagsFromVkResolveModeFlags(VkResolveModeFlags flags);
 
 GpuInstance *gpuInit(const WpAllocator *allocator, GpuInitRequest request) {
 	assertWithLogger(volkInitialize() == VK_SUCCESS, &logger, "Failed to initialise volk");
@@ -697,6 +712,26 @@ GpuFormat gpuGetSwapchainDepthFormat(GpuSwapchain *swapchain) {
 	return gpuFormatFromVkFormat(swapchain->depth.format);
 }
 
+u64 gpuAcquireNextSwapchainImage(GpuSwapchainAcquireImageRequest request) {
+	u32 output = 0;
+
+	VkAcquireNextImageInfoKHR info = {
+		.sType     = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR,
+		.swapchain = request.swapchain->vk_swapchain,
+		.timeout   = request.timeout,
+		.semaphore = request.semaphore != NULL ? request.semaphore->vk_semaphore : VK_NULL_HANDLE,
+		.fence     = request.fence     != NULL ? request.fence->vk_fence         : VK_NULL_HANDLE,
+	};
+	VkResult vk_result = vkAcquireNextImage2KHR(request.swapchain->device->vk_device, &info, &output);
+	assertWithLogger(vk_result == VK_SUCCESS, &logger, "Failed to acquire next swapchain image");
+
+	WpStr8 msg = wpStr8Buf(4096);
+	wpStr8Format(&msg, "Acquired swapchain image #%" PRIu32, output);
+	wpLogDebug(&logger, msg);
+
+	return output;
+}
+
 GpuSampler *gpuCreateSampler(const WpAllocator *allocator, GpuSamplerCreateRequest request) {
 	GpuSampler *output = wpMemAllocatorAlloc(allocator, sizeof(GpuSampler));
 	assertWithLogger(output != NULL, &logger, "Failed to allocate sampler");
@@ -958,13 +993,13 @@ GpuCommandBufferPtrArray gpuAllocateCommandBuffers(const WpAllocator *allocator,
 	return buffers;
 }
 
-void gpuBeginCommandBuffer(GpuCommandBuffer *buffer) {
+void gpuBeginCommandBuffer(GpuCommandBufferBeginRequest request) {
 	VkCommandBufferBeginInfo info = {
 		.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
-		.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
+		.flags = request.one_time_submit ? VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT : 0,
 	};
 
-	VkResult vk_result = vkBeginCommandBuffer(buffer->vk_buffer, &info);
+	VkResult vk_result = vkBeginCommandBuffer(request.command_buffer->vk_buffer, &info);
 	assertWithLogger(vk_result == VK_SUCCESS, &logger, "Failed to begin command buffer");
 }
 
@@ -974,14 +1009,14 @@ void gpuEndCommandBuffer(GpuCommandBuffer *buffer) {
 }
 
 void gpuSubmitCommandBuffers(const WpAllocator *temp, GpuCommandBuffersSubmitRequest request) {
-	u64 buffer_count = wpArrayCount(request.buffers);
+	u64 buffer_count = wpArrayCount(request.command_buffers);
 
 	VkCommandBufferArray vk_buffers  = wpArrayAllocCapacity(VkCommandBuffer, temp, buffer_count,
 	                                                        WP_ARRAY_INIT_FILLED);
 	assertWithLogger(vk_buffers != NULL, &logger, "Failed to allocate temp buffers");
 
 	for (u64 i = 0; i < buffer_count; ++i) {
-		vk_buffers[i] = request.buffers[i]->vk_buffer;
+		vk_buffers[i] = request.command_buffers[i]->vk_buffer;
 	}
 
 	VkSubmitInfo info = {
@@ -1578,6 +1613,281 @@ void gpuDeviceWaitIdle(GpuDevice *device) {
 	vkDeviceWaitIdle(device->vk_device);
 }
 
+void gpuCmdPipelineBarrier(const WpAllocator *temp, GpuCmdPipelineBarrierRequest request) {
+	u64 memory_barrier_count        = request.info.memory_barriers != NULL ?
+	                                  wpArrayCount(request.info.memory_barriers) : 0;
+	u64 image_memory_barrier_count  = request.info.image_memory_barriers != NULL ?
+	                                  wpArrayCount(request.info.image_memory_barriers) : 0;
+	u64 buffer_memory_barrier_count = request.info.buffer_memory_barriers != NULL ?
+	                                  wpArrayCount(request.info.buffer_memory_barriers) : 0;
+
+	VkMemoryBarrier2Array memory_barriers = NULL;
+	if (memory_barrier_count > 0) {
+		memory_barriers = wpArrayAllocCapacity(VkMemoryBarrier2, temp, memory_barrier_count, WP_ARRAY_INIT_FILLED);
+		assertWithLogger(memory_barriers != NULL, &logger, "Failed to allocate temp memory barriers array");
+
+		for (u64 i = 0; i < memory_barrier_count; ++i) {
+			memory_barriers[i] = (VkMemoryBarrier2){
+				.sType         = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
+				.srcStageMask  = vkPipelineStagesFromGpuPipelineStages(request.info.memory_barriers[i].src_stage_mask),
+				.srcAccessMask = vkAccessFlagsFromGpuAccessFlags(request.info.memory_barriers[i].src_access_mask),
+				.dstStageMask  = vkPipelineStagesFromGpuPipelineStages(request.info.memory_barriers[i].dst_stage_mask),
+				.dstAccessMask = vkAccessFlagsFromGpuAccessFlags(request.info.memory_barriers[i].dst_access_mask),
+			};
+		}
+	}
+
+	VkImageMemoryBarrier2Array image_memory_barriers = NULL;
+	if (image_memory_barrier_count > 0) {
+		image_memory_barriers = wpArrayAllocCapacity(VkImageMemoryBarrier2, temp, image_memory_barrier_count,
+		                                             WP_ARRAY_INIT_FILLED);
+		assertWithLogger(image_memory_barriers != NULL, &logger, "Failed to allocate temp image memory barriers array");
+
+		for (u64 i = 0; i < image_memory_barrier_count; ++i) {
+			image_memory_barriers[i] = (VkImageMemoryBarrier2){
+				.sType               = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
+				.srcStageMask        = vkPipelineStagesFromGpuPipelineStages(request.info.image_memory_barriers[i].src_stage_mask),
+				.srcAccessMask       = vkAccessFlagsFromGpuAccessFlags(request.info.image_memory_barriers[i].src_access_mask),
+				.dstStageMask        = vkPipelineStagesFromGpuPipelineStages(request.info.image_memory_barriers[i].dst_stage_mask),
+				.dstAccessMask       = vkAccessFlagsFromGpuAccessFlags(request.info.image_memory_barriers[i].dst_access_mask),
+				.oldLayout           = vkImageLayoutFromGpuImageLayout(request.info.image_memory_barriers[i].old_layout),
+				.newLayout           = vkImageLayoutFromGpuImageLayout(request.info.image_memory_barriers[i].new_layout),
+				.srcQueueFamilyIndex = request.info.image_memory_barriers[i].src_queue_family_index,
+				.dstQueueFamilyIndex = request.info.image_memory_barriers[i].dst_queue_family_index,
+				.image               = request.info.image_memory_barriers[i].image->vk_image,
+				.subresourceRange    = (VkImageSubresourceRange){
+					.aspectMask     = vkImageAspectFromGpuImageAspect(request.info.image_memory_barriers[i].subresource.aspect),
+					.baseMipLevel   = request.info.image_memory_barriers[i].subresource.base_mip_level,
+					.levelCount     = request.info.image_memory_barriers[i].subresource.level_count,
+					.baseArrayLayer = request.info.image_memory_barriers[i].subresource.base_array_layer,
+					.layerCount     = request.info.image_memory_barriers[i].subresource.layer_count,
+				},
+			};
+		}
+	}
+
+	VkBufferMemoryBarrier2Array buffer_memory_barriers = NULL;
+	if (buffer_memory_barrier_count > 0) {
+		buffer_memory_barriers = wpArrayAllocCapacity(VkBufferMemoryBarrier2, temp, buffer_memory_barrier_count,
+		                                              WP_ARRAY_INIT_FILLED);
+		assertWithLogger(buffer_memory_barriers != NULL, &logger, "Failed to allocate temp buffer memory barriers array");
+
+		for (u64 i = 0; i < buffer_memory_barrier_count; ++i) {
+			buffer_memory_barriers[i] = (VkBufferMemoryBarrier2){
+				.sType               = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
+				.srcStageMask        = vkPipelineStagesFromGpuPipelineStages(request.info.buffer_memory_barriers[i].src_stage_mask),
+				.srcAccessMask       = vkAccessFlagsFromGpuAccessFlags(request.info.buffer_memory_barriers[i].src_access_mask),
+				.dstStageMask        = vkPipelineStagesFromGpuPipelineStages(request.info.buffer_memory_barriers[i].dst_stage_mask),
+				.dstAccessMask       = vkAccessFlagsFromGpuAccessFlags(request.info.buffer_memory_barriers[i].dst_access_mask),
+				.srcQueueFamilyIndex = request.info.buffer_memory_barriers[i].src_queue_family_index,
+				.dstQueueFamilyIndex = request.info.buffer_memory_barriers[i].dst_queue_family_index,
+				.buffer              = request.info.buffer_memory_barriers[i].buffer->internal->vk_buffer,
+				.offset              = request.info.buffer_memory_barriers[i].offset,
+				.size                = request.info.buffer_memory_barriers[i].buffer->size,
+			};
+		}
+	}
+
+	VkDependencyInfo info = {
+		.sType                    = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
+		.memoryBarrierCount       = memory_barrier_count,
+		.pMemoryBarriers          = memory_barriers,
+		.bufferMemoryBarrierCount = buffer_memory_barrier_count,
+		.pBufferMemoryBarriers    = buffer_memory_barriers,
+		.imageMemoryBarrierCount  = image_memory_barrier_count,
+		.pImageMemoryBarriers     = image_memory_barriers,
+	};
+	vkCmdPipelineBarrier2(request.command_buffer->vk_buffer, &info);
+}
+
+void gpuCmdBeginRendering(const WpAllocator *temp, GpuCmdBeginRenderingRequest request) {
+	u64 color_attachment_count = wpArrayCount(request.color_attachments);
+	VkRenderingAttachmentInfoArray color_attachments = wpArrayAllocCapacity(VkRenderingAttachmentInfo,
+	                                                                        temp, color_attachment_count,
+	                                                                        WP_ARRAY_INIT_FILLED);
+	assertWithLogger(color_attachments != NULL, &logger, "Failed to allocate temp color attachments array");
+
+	for (u64 i = 0; i < color_attachment_count; ++i) {
+		color_attachments[i] = (VkRenderingAttachmentInfo){
+			.sType              = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
+			.imageView          = request.color_attachments[i].image->vk_view,
+			.imageLayout        = vkImageLayoutFromGpuImageLayout(request.color_attachments[i].layout),
+			.resolveMode        = vkResolveModeFlagsFromGpuResolveModeFlags(request.color_attachments[i].resolve_mode),
+			.resolveImageView   = request.color_attachments[i].resolve_image->vk_view,
+			.resolveImageLayout = vkImageLayoutFromGpuImageLayout(request.color_attachments[i].resolve_image_layout),
+			.loadOp             = vkAttachmentLoadOpFromGpuAttachmentLoadOp(request.color_attachments[i].load_op),
+			.storeOp            = vkAttachmentStoreOpFromGpuAttachmentStoreOp(request.color_attachments[i].store_op),
+			.clearValue         = (VkClearValue){
+				.depthStencil = (VkClearDepthStencilValue){
+					.depth   = request.color_attachments[i].clear_value.depth_stencil.depth,
+					.stencil = request.color_attachments[i].clear_value.depth_stencil.stencil,
+				}
+			},
+		};
+	}
+
+	VkRenderingAttachmentInfo depth_attachment = {0};
+	if (request.depth_attachment != NULL) {
+		depth_attachment = (VkRenderingAttachmentInfo){
+			.sType              = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
+			.imageView          = request.depth_attachment->image->vk_view,
+			.imageLayout        = vkImageLayoutFromGpuImageLayout(request.depth_attachment->layout),
+			.resolveMode        = vkResolveModeFlagsFromGpuResolveModeFlags(request.depth_attachment->resolve_mode),
+			.resolveImageView   = request.depth_attachment->resolve_image->vk_view,
+			.resolveImageLayout = vkImageLayoutFromGpuImageLayout(request.depth_attachment->resolve_image_layout),
+			.loadOp             = vkAttachmentLoadOpFromGpuAttachmentLoadOp(request.depth_attachment->load_op),
+			.storeOp            = vkAttachmentStoreOpFromGpuAttachmentStoreOp(request.depth_attachment->store_op),
+			.clearValue         = (VkClearValue){
+				.depthStencil = (VkClearDepthStencilValue){
+					.depth   = request.depth_attachment->clear_value.depth_stencil.depth,
+					.stencil = request.depth_attachment->clear_value.depth_stencil.stencil,
+				}
+			},
+		};
+	}
+
+	VkRenderingAttachmentInfo stencil_attachment = {0};
+	if (request.stencil_attachment != NULL) {
+		stencil_attachment = (VkRenderingAttachmentInfo){
+			.sType              = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
+			.imageView          = request.stencil_attachment->image->vk_view,
+			.imageLayout        = vkImageLayoutFromGpuImageLayout(request.stencil_attachment->layout),
+			.resolveMode        = vkResolveModeFlagsFromGpuResolveModeFlags(request.stencil_attachment->resolve_mode),
+			.resolveImageView   = request.stencil_attachment->resolve_image->vk_view,
+			.resolveImageLayout = vkImageLayoutFromGpuImageLayout(request.stencil_attachment->resolve_image_layout),
+			.loadOp             = vkAttachmentLoadOpFromGpuAttachmentLoadOp(request.stencil_attachment->load_op),
+			.storeOp            = vkAttachmentStoreOpFromGpuAttachmentStoreOp(request.stencil_attachment->store_op),
+			.clearValue         = (VkClearValue){
+				.depthStencil = (VkClearDepthStencilValue){
+					.depth   = request.stencil_attachment->clear_value.depth_stencil.depth,
+					.stencil = request.stencil_attachment->clear_value.depth_stencil.stencil,
+				}
+			},
+		};
+	}
+
+	VkRenderingInfo info = {
+		.sType                = VK_STRUCTURE_TYPE_RENDERING_INFO,
+		.renderArea           = (VkRect2D){
+			.offset = { .x = request.render_area.offset.x, .y = request.render_area.offset.y },
+			.extent = { .width = request.render_area.extent.width, .height = request.render_area.extent.height },
+		},
+		.layerCount           = request.layer_count,
+		.viewMask             = request.view_mask,
+		.colorAttachmentCount = color_attachment_count,
+		.pColorAttachments    = color_attachments,
+		.pDepthAttachment     = request.depth_attachment   != NULL ? &depth_attachment   : NULL,
+		.pStencilAttachment   = request.stencil_attachment != NULL ? &stencil_attachment : NULL,
+	};
+	vkCmdBeginRendering(request.command_buffer->vk_buffer, &info);
+}
+
+void gpuCmdEndRendering(GpuCommandBuffer *buffer) {
+	vkCmdEndRendering(buffer->vk_buffer);
+}
+
+void gpuCmdSetViewport(const WpAllocator *temp, GpuCmdSetViewportRequest request) {
+	u64 viewport_count        = wpArrayCount(request.viewports);
+	VkViewportArray viewports = wpArrayAllocCapacity(VkViewport, temp, viewport_count, WP_ARRAY_INIT_FILLED);
+	assertWithLogger(viewports != NULL, &logger, "Failed to allocate temp viewports array");
+
+	for (u64 i = 0; i < viewport_count; ++i) {
+		viewports[i] = (VkViewport){
+			.x        = request.viewports[i].x,
+			.y        = request.viewports[i].y,
+			.width    = request.viewports[i].width,
+			.height   = request.viewports[i].height,
+			.minDepth = request.viewports[i].min_depth,
+			.maxDepth = request.viewports[i].max_depth,
+		};
+	}
+
+	vkCmdSetViewport(request.command_buffer->vk_buffer, 0, viewport_count, viewports);
+}
+
+void gpuCmdSetScissor(const WpAllocator *temp, GpuCmdSetScissorRequest request) {
+	u64 scissor_count      = wpArrayCount(request.scissors);
+	VkRect2DArray scissors = wpArrayAllocCapacity(VkRect2D, temp, scissor_count, WP_ARRAY_INIT_FILLED);
+	assertWithLogger(scissors != NULL, &logger, "Failed to allocate temp scissors array");
+
+	for (u64 i = 0; i < scissor_count; ++i) {
+		scissors[i] = (VkRect2D){
+			.offset = (VkOffset2D){
+				.x = request.scissors[i].offset.x,
+				.y = request.scissors[i].offset.y,
+			},
+			.extent = (VkExtent2D){
+				.width  = request.scissors[i].extent.width,
+				.height = request.scissors[i].extent.height,
+			},
+		};
+	}
+
+	vkCmdSetScissor(request.command_buffer->vk_buffer, 0, scissor_count, scissors);
+}
+
+void gpuCmdBindPipeline(GpuCmdBindPipelineRequest request) {
+	vkCmdBindPipeline(request.command_buffer->vk_buffer,
+	                  vkPipelineBindPointFromGpuPipelineBindPoint(request.bind_point),
+	                  request.pipeline->vk_pipeline);
+}
+
+void gpuCmdBindDescriptorSets(const WpAllocator *temp, GpuCmdBindDescriptorSetsRequest request) {
+	u64 set_count             = wpArrayCount(request.sets);
+	VkDescriptorSetArray sets = wpArrayAllocCapacity(VkDescriptorSet, temp, set_count, WP_ARRAY_INIT_FILLED);
+	assertWithLogger(sets != NULL, &logger, "Failed to allocate temp descriptor sets array");
+
+	for (u64 i = 0; i < set_count; ++i) {
+		sets[i] = request.sets[i]->vk_set;
+	}
+
+	vkCmdBindDescriptorSets(request.command_buffer->vk_buffer,
+	                        vkPipelineBindPointFromGpuPipelineBindPoint(request.bind_point),
+	                        request.layout->vk_layout, 0, set_count, sets, 0, NULL);
+}
+
+void gpuCmdBindVertexBuffers(const WpAllocator *temp, GpuCmdBindVertexBuffersRequest request) {
+	u64 buffer_count = wpArrayCount(request.vertex_buffers);
+	u64 offset_count = wpArrayCount(request.offsets);
+	assertWithLogger(buffer_count == offset_count, &logger, "Buffer count and offset count do not match");
+
+	VkBufferArray buffers = wpArrayAllocCapacity(VkBuffer, temp, buffer_count, WP_ARRAY_INIT_FILLED);
+	assertWithLogger(buffers != NULL, &logger, "Failed to allocate temp vertex buffers array");
+
+	for (u64 i = 0; i < buffer_count; ++i) {
+		buffers[i] = request.vertex_buffers[i].internal->vk_buffer;
+	}
+
+	vkCmdBindVertexBuffers(request.command_buffer->vk_buffer, 0, buffer_count, buffers, request.offsets);
+}
+
+void gpuCmdBindIndexBuffer(GpuCmdBindIndexBufferRequest request) {
+	vkCmdBindIndexBuffer(request.command_buffer->vk_buffer, request.index_buffer.internal->vk_buffer,
+	                     request.offset, vkIndexTypeFromGpuIndexType(request.index_type));
+}
+
+void gpuCmdPushConstants(GpuCmdPushConstantsRequest request) {
+	vkCmdPushConstants(request.command_buffer->vk_buffer, request.layout->vk_layout,
+	                   vkShaderStageFromGpuShaderStage(request.stage_flags), request.offset,
+	                   request.total_size_in_bytes, request.values);
+}
+
+void gpuCmdDrawIndexed(GpuCmdDrawIndexedRequest request) {
+	vkCmdDrawIndexed(request.command_buffer->vk_buffer, request.index_count, request.instance_count,
+	                 request.first_index, request.vertex_offset, request.first_instance);
+}
+
+void gpuCmdDispatch(GpuCmdDispatchRequest request) {
+	vkCmdDispatch(request.command_buffer->vk_buffer, request.group_count_x,
+	              request.group_count_y, request.group_count_z);
+}
+
+void gpuCmdDispatchBase(GpuCmdDispatchBaseRequest request) {
+	vkCmdDispatchBase(request.command_buffer->vk_buffer, request.base_group_x, request.base_group_y,
+	                  request.base_group_z, request.group_count_x, request.group_count_y,
+	                  request.group_count_z);
+}
+
 wp_intern VkExtensions getInstanceExtensions(void) {
 	Config config       = configGet();
 	VkExtensions output = {0};
@@ -1897,26 +2207,26 @@ wp_intern GpuImageType gpuImageTypeFromVkImageViewType(VkImageViewType type) {
 
 wp_intern VkSampleCountFlagBits vkSampleCountFromGpuSampleCount(GpuSampleCount samples) {
 	switch (samples) {
-		case GPU_SAMPLE_COUNT_1_BIT:  return VK_SAMPLE_COUNT_1_BIT;
+		case GPU_SAMPLE_COUNT_1:  return VK_SAMPLE_COUNT_1_BIT;
-		case GPU_SAMPLE_COUNT_2_BIT:  return VK_SAMPLE_COUNT_2_BIT;
+		case GPU_SAMPLE_COUNT_2:  return VK_SAMPLE_COUNT_2_BIT;
-		case GPU_SAMPLE_COUNT_4_BIT:  return VK_SAMPLE_COUNT_4_BIT;
+		case GPU_SAMPLE_COUNT_4:  return VK_SAMPLE_COUNT_4_BIT;
-		case GPU_SAMPLE_COUNT_8_BIT:  return VK_SAMPLE_COUNT_8_BIT;
+		case GPU_SAMPLE_COUNT_8:  return VK_SAMPLE_COUNT_8_BIT;
-		case GPU_SAMPLE_COUNT_16_BIT: return VK_SAMPLE_COUNT_16_BIT;
+		case GPU_SAMPLE_COUNT_16: return VK_SAMPLE_COUNT_16_BIT;
-		case GPU_SAMPLE_COUNT_32_BIT: return VK_SAMPLE_COUNT_32_BIT;
+		case GPU_SAMPLE_COUNT_32: return VK_SAMPLE_COUNT_32_BIT;
-		case GPU_SAMPLE_COUNT_64_BIT: return VK_SAMPLE_COUNT_64_BIT;
+		case GPU_SAMPLE_COUNT_64: return VK_SAMPLE_COUNT_64_BIT;
 	}
 }
 
 wp_intern GpuSampleCount gpuSampleCountFromVkSampleCount(VkSampleCountFlagBits samples) {
 	switch (samples) {
-		case VK_SAMPLE_COUNT_1_BIT:  return GPU_SAMPLE_COUNT_1_BIT;
+		case VK_SAMPLE_COUNT_1_BIT:  return GPU_SAMPLE_COUNT_1;
-		case VK_SAMPLE_COUNT_2_BIT:  return GPU_SAMPLE_COUNT_2_BIT;
+		case VK_SAMPLE_COUNT_2_BIT:  return GPU_SAMPLE_COUNT_2;
-		case VK_SAMPLE_COUNT_4_BIT:  return GPU_SAMPLE_COUNT_4_BIT;
+		case VK_SAMPLE_COUNT_4_BIT:  return GPU_SAMPLE_COUNT_4;
-		case VK_SAMPLE_COUNT_8_BIT:  return GPU_SAMPLE_COUNT_8_BIT;
+		case VK_SAMPLE_COUNT_8_BIT:  return GPU_SAMPLE_COUNT_8;
-		case VK_SAMPLE_COUNT_16_BIT: return GPU_SAMPLE_COUNT_16_BIT;
+		case VK_SAMPLE_COUNT_16_BIT: return GPU_SAMPLE_COUNT_16;
-		case VK_SAMPLE_COUNT_32_BIT: return GPU_SAMPLE_COUNT_32_BIT;
+		case VK_SAMPLE_COUNT_32_BIT: return GPU_SAMPLE_COUNT_32;
-		case VK_SAMPLE_COUNT_64_BIT: return GPU_SAMPLE_COUNT_64_BIT;
+		case VK_SAMPLE_COUNT_64_BIT: return GPU_SAMPLE_COUNT_64;
-		default:                     return GPU_SAMPLE_COUNT_1_BIT;
+		default:                     return GPU_SAMPLE_COUNT_1;
 	}
 }
 
@@ -2041,9 +2351,9 @@ wp_intern GpuImageLayout gpuImageLayoutFromVkImageLayout(VkImageLayout layout) {
 wp_intern VkImageAspectFlags vkImageAspectFromGpuImageAspect(GpuImageAspect aspect) {
 	VkImageAspectFlags output = VK_IMAGE_ASPECT_NONE;
 
-	output |= (aspect & GPU_IMAGE_ASPECT_COLOR_BIT)   != 0 ? VK_IMAGE_ASPECT_COLOR_BIT   : 0;
+	output |= (aspect & GPU_IMAGE_ASPECT_COLOR)   != 0 ? VK_IMAGE_ASPECT_COLOR_BIT   : 0;
-	output |= (aspect & GPU_IMAGE_ASPECT_DEPTH_BIT)   != 0 ? VK_IMAGE_ASPECT_DEPTH_BIT   : 0;
+	output |= (aspect & GPU_IMAGE_ASPECT_DEPTH)   != 0 ? VK_IMAGE_ASPECT_DEPTH_BIT   : 0;
-	output |= (aspect & GPU_IMAGE_ASPECT_STENCIL_BIT) != 0 ? VK_IMAGE_ASPECT_STENCIL_BIT : 0;
+	output |= (aspect & GPU_IMAGE_ASPECT_STENCIL) != 0 ? VK_IMAGE_ASPECT_STENCIL_BIT : 0;
 
 	return output;
 }
@@ -2051,9 +2361,9 @@ wp_intern VkImageAspectFlags vkImageAspectFromGpuImageAspect(GpuImageAspect aspe
 wp_intern GpuImageAspect gpuImageAspectFromVkImageAspect(VkImageAspectFlags aspect) {
 	GpuImageAspect output = GPU_IMAGE_ASPECT_NONE;
 
-	output |= (aspect & VK_IMAGE_ASPECT_COLOR_BIT)   != 0 ? GPU_IMAGE_ASPECT_COLOR_BIT   : 0;
+	output |= (aspect & VK_IMAGE_ASPECT_COLOR_BIT)   != 0 ? GPU_IMAGE_ASPECT_COLOR   : 0;
-	output |= (aspect & VK_IMAGE_ASPECT_DEPTH_BIT)   != 0 ? GPU_IMAGE_ASPECT_DEPTH_BIT   : 0;
+	output |= (aspect & VK_IMAGE_ASPECT_DEPTH_BIT)   != 0 ? GPU_IMAGE_ASPECT_DEPTH   : 0;
-	output |= (aspect & VK_IMAGE_ASPECT_STENCIL_BIT) != 0 ? GPU_IMAGE_ASPECT_STENCIL_BIT : 0;
+	output |= (aspect & VK_IMAGE_ASPECT_STENCIL_BIT) != 0 ? GPU_IMAGE_ASPECT_STENCIL : 0;
 
 	return output;
 }
@@ -2872,3 +3182,96 @@ wp_intern GpuLogicOp gpuLogicOpFromVkLogicOp(VkLogicOp op) {
 		default:                        return GPU_LOGIC_OP_CLEAR;
 	}
 }
+
+wp_intern VkPipelineBindPoint vkPipelineBindPointFromGpuPipelineBindPoint(GpuPipelineBindPoint binding) {
+	switch (binding) {
+		case GPU_PIPELINE_BIND_POINT_GRAPHICS:    return VK_PIPELINE_BIND_POINT_GRAPHICS;
+		case GPU_PIPELINE_BIND_POINT_COMPUTE:     return VK_PIPELINE_BIND_POINT_COMPUTE;
+		case GPU_PIPELINE_BIND_POINT_RAY_TRACING: return VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
+	}
+}
+
+wp_intern GpuPipelineBindPoint gpuPipelineBindPointFromVkPipelineBindPoint(VkPipelineBindPoint binding) {
+	switch (binding) {
+		case VK_PIPELINE_BIND_POINT_GRAPHICS:        return GPU_PIPELINE_BIND_POINT_GRAPHICS;
+		case VK_PIPELINE_BIND_POINT_COMPUTE:         return GPU_PIPELINE_BIND_POINT_COMPUTE;
+		case VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR: return GPU_PIPELINE_BIND_POINT_RAY_TRACING;
+		default:                                     return GPU_PIPELINE_BIND_POINT_GRAPHICS;
+	}
+}
+
+wp_intern VkIndexType vkIndexTypeFromGpuIndexType(GpuIndexType type) {
+	switch (type) {
+		case GPU_INDEX_TYPE_NONE:   return VK_INDEX_TYPE_NONE_KHR;
+		case GPU_INDEX_TYPE_UINT16: return VK_INDEX_TYPE_UINT16;
+		case GPU_INDEX_TYPE_UINT32: return VK_INDEX_TYPE_UINT32;
+		case GPU_INDEX_TYPE_UINT8:  return VK_INDEX_TYPE_UINT8;
+	}
+}
+
+wp_intern GpuIndexType gpuIndexTypeFromVkIndexType(VkIndexType type) {
+	switch (type) {
+		case VK_INDEX_TYPE_UINT16: return GPU_INDEX_TYPE_UINT16;
+		case VK_INDEX_TYPE_UINT32: return GPU_INDEX_TYPE_UINT32;
+		case VK_INDEX_TYPE_UINT8:  return GPU_INDEX_TYPE_UINT8;
+		default:                   return GPU_INDEX_TYPE_NONE;
+	}
+}
+
+wp_intern VkAttachmentLoadOp vkAttachmentLoadOpFromGpuAttachmentLoadOp(GpuAttachmentLoadOp op) {
+	switch (op) {
+		case GPU_ATTACHMENT_LOAD_OP_LOAD:      return VK_ATTACHMENT_LOAD_OP_LOAD;
+		case GPU_ATTACHMENT_LOAD_OP_CLEAR:     return VK_ATTACHMENT_LOAD_OP_CLEAR;
+		case GPU_ATTACHMENT_LOAD_OP_DONT_CARE: return VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+		default:                               return VK_ATTACHMENT_LOAD_OP_NONE;
+	}
+}
+
+wp_intern GpuAttachmentLoadOp gpuAttachmentLoadOpFromVkAttachmentLoadOp(VkAttachmentLoadOp op) {
+	switch (op) {
+		case VK_ATTACHMENT_LOAD_OP_LOAD:      return GPU_ATTACHMENT_LOAD_OP_LOAD;
+		case VK_ATTACHMENT_LOAD_OP_CLEAR:     return GPU_ATTACHMENT_LOAD_OP_CLEAR;
+		case VK_ATTACHMENT_LOAD_OP_DONT_CARE: return GPU_ATTACHMENT_LOAD_OP_DONT_CARE;
+		default:                              return GPU_ATTACHMENT_LOAD_OP_NONE;
+	}
+}
+
+wp_intern VkAttachmentStoreOp vkAttachmentStoreOpFromGpuAttachmentStoreOp(GpuAttachmentStoreOp op) {
+	switch (op) {
+		case GPU_ATTACHMENT_STORE_OP_STORE:     return VK_ATTACHMENT_STORE_OP_STORE;
+		case GPU_ATTACHMENT_STORE_OP_DONT_CARE: return VK_ATTACHMENT_STORE_OP_DONT_CARE;
+		default:                                return VK_ATTACHMENT_STORE_OP_NONE;
+	}
+}
+
+wp_intern GpuAttachmentStoreOp gpuAttachmentStoreOpFromVkAttachmentStoreOp(VkAttachmentStoreOp op) {
+	switch (op) {
+		case VK_ATTACHMENT_STORE_OP_STORE:     return GPU_ATTACHMENT_STORE_OP_STORE;
+		case VK_ATTACHMENT_STORE_OP_DONT_CARE: return GPU_ATTACHMENT_STORE_OP_DONT_CARE;
+		default:                               return GPU_ATTACHMENT_STORE_OP_NONE;
+	}
+}
+
+wp_intern VkResolveModeFlagBits vkResolveModeFlagsFromGpuResolveModeFlags(GpuResolveModeFlags flags) {
+	VkResolveModeFlagBits output = VK_RESOLVE_MODE_NONE;
+
+	output |= (flags & GPU_RESOLVE_MODE_NONE)        != 0 ? VK_RESOLVE_MODE_NONE            : 0;
+	output |= (flags & GPU_RESOLVE_MODE_SAMPLE_ZERO) != 0 ? VK_RESOLVE_MODE_SAMPLE_ZERO_BIT : 0;
+	output |= (flags & GPU_RESOLVE_MODE_AVERAGE)     != 0 ? VK_RESOLVE_MODE_AVERAGE_BIT     : 0;
+	output |= (flags & GPU_RESOLVE_MODE_MIN)         != 0 ? VK_RESOLVE_MODE_MIN_BIT         : 0;
+	output |= (flags & GPU_RESOLVE_MODE_MAX)         != 0 ? VK_RESOLVE_MODE_MAX_BIT         : 0;
+
+	return output;
+}
+
+wp_intern GpuResolveModeFlags gpuResolveModeFlagsFromVkResolveModeFlags(VkResolveModeFlags flags) {
+	GpuResolveModeFlags output = GPU_RESOLVE_MODE_NONE;
+
+	output |= (flags & VK_RESOLVE_MODE_NONE)            != 0 ? GPU_RESOLVE_MODE_NONE        : 0;
+	output |= (flags & VK_RESOLVE_MODE_SAMPLE_ZERO_BIT) != 0 ? GPU_RESOLVE_MODE_SAMPLE_ZERO : 0;
+	output |= (flags & VK_RESOLVE_MODE_AVERAGE_BIT)     != 0 ? GPU_RESOLVE_MODE_AVERAGE     : 0;
+	output |= (flags & VK_RESOLVE_MODE_MIN_BIT)         != 0 ? GPU_RESOLVE_MODE_MIN         : 0;
+	output |= (flags & VK_RESOLVE_MODE_MAX_BIT)         != 0 ? GPU_RESOLVE_MODE_MAX         : 0;
+
+	return output;
+}

src/main.c

@@ -121,14 +121,16 @@ i32 main(void) {
 	};
 	GpuCommandBufferPtrArray buffers = gpuAllocateCommandBuffers(&arena, &temp_arena, buf_alloc_request);
 
-	GpuCommandBuffer *cmd = buffers[0];
+	GpuCommandBufferBeginRequest cb_request = {
-	gpuBeginCommandBuffer(cmd);
+		.command_buffer = buffers[0],
-	gpuEndCommandBuffer(cmd);
+	};
+	gpuBeginCommandBuffer(cb_request);
+	gpuEndCommandBuffer(buffers[0]);
 
 	GpuCommandBuffersSubmitRequest cmd_submit_request = {
 		.device  = device,
 		.fence   = fence,
-		.buffers = wpArray(GpuCommandBuffer *, cmd),
+		.command_buffers = wpArray(GpuCommandBuffer *, buffers[0]),
 	};
 	gpuSubmitCommandBuffers(&temp_arena, cmd_submit_request);
 
@@ -266,7 +268,7 @@ i32 main(void) {
 				},
 				.rasterization_state     = (GpuPipelineRasterizationStateInfo){ .line_width = 1.0f },
 				.multisample_state       = (GpuPipelineMultisampleStateInfo){
-					.rasterization_samples = GPU_SAMPLE_COUNT_1_BIT 
+					.rasterization_samples = GPU_SAMPLE_COUNT_1 
 				},
 				.depth_stencil_state     = (GpuPipelineDepthStencilStateInfo){
 					.depth_test_enable  = true,