diff --git a/src/gpu/gpu.h b/src/gpu/gpu.h index d98213d..3122268 100644 --- a/src/gpu/gpu.h +++ b/src/gpu/gpu.h @@ -215,13 +215,13 @@ typedef enum GpuImageType { } GpuImageType; typedef enum GpuSampleCount { - GPU_SAMPLE_COUNT_1_BIT, - GPU_SAMPLE_COUNT_2_BIT, - GPU_SAMPLE_COUNT_4_BIT, - GPU_SAMPLE_COUNT_8_BIT, - GPU_SAMPLE_COUNT_16_BIT, - GPU_SAMPLE_COUNT_32_BIT, - GPU_SAMPLE_COUNT_64_BIT, + GPU_SAMPLE_COUNT_1, + GPU_SAMPLE_COUNT_2, + GPU_SAMPLE_COUNT_4, + GPU_SAMPLE_COUNT_8, + GPU_SAMPLE_COUNT_16, + GPU_SAMPLE_COUNT_32, + GPU_SAMPLE_COUNT_64, } GpuSampleCount; typedef enum GpuImageTiling { @@ -276,10 +276,10 @@ typedef enum GpuImageLayout { } GpuImageLayout; typedef enum GpuImageAspect { - GPU_IMAGE_ASPECT_NONE = 0, - GPU_IMAGE_ASPECT_COLOR_BIT = 1 << 0, - GPU_IMAGE_ASPECT_DEPTH_BIT = 1 << 1, - GPU_IMAGE_ASPECT_STENCIL_BIT = 1 << 2, + GPU_IMAGE_ASPECT_NONE = 0, + GPU_IMAGE_ASPECT_COLOR = 1 << 0, + GPU_IMAGE_ASPECT_DEPTH = 1 << 1, + 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 { - GpuPipelineStageFlags src_stage_mask; - GpuPipelineStageFlags dst_stage_mask; - GpuAccessFlags src_access_mask; - 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 GpuCommandBufferBeginRequest { + GpuCommandBuffer *command_buffer; + b32 one_time_submit; +} GpuCommandBufferBeginRequest; 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 diff --git a/src/gpu/vulkan/vk_gpu.c b/src/gpu/vulkan/vk_gpu.c index 93cb5ad..7d4cf7b 100644 --- a/src/gpu/vulkan/vk_gpu.c +++ b/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_2_BIT: return VK_SAMPLE_COUNT_2_BIT; - case GPU_SAMPLE_COUNT_4_BIT: return VK_SAMPLE_COUNT_4_BIT; - case GPU_SAMPLE_COUNT_8_BIT: return VK_SAMPLE_COUNT_8_BIT; - case GPU_SAMPLE_COUNT_16_BIT: return VK_SAMPLE_COUNT_16_BIT; - case GPU_SAMPLE_COUNT_32_BIT: return VK_SAMPLE_COUNT_32_BIT; - case GPU_SAMPLE_COUNT_64_BIT: return VK_SAMPLE_COUNT_64_BIT; + case GPU_SAMPLE_COUNT_1: return VK_SAMPLE_COUNT_1_BIT; + case GPU_SAMPLE_COUNT_2: return VK_SAMPLE_COUNT_2_BIT; + case GPU_SAMPLE_COUNT_4: return VK_SAMPLE_COUNT_4_BIT; + case GPU_SAMPLE_COUNT_8: return VK_SAMPLE_COUNT_8_BIT; + case GPU_SAMPLE_COUNT_16: return VK_SAMPLE_COUNT_16_BIT; + case GPU_SAMPLE_COUNT_32: return VK_SAMPLE_COUNT_32_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_2_BIT: return GPU_SAMPLE_COUNT_2_BIT; - case VK_SAMPLE_COUNT_4_BIT: return GPU_SAMPLE_COUNT_4_BIT; - case VK_SAMPLE_COUNT_8_BIT: return GPU_SAMPLE_COUNT_8_BIT; - case VK_SAMPLE_COUNT_16_BIT: return GPU_SAMPLE_COUNT_16_BIT; - case VK_SAMPLE_COUNT_32_BIT: return GPU_SAMPLE_COUNT_32_BIT; - case VK_SAMPLE_COUNT_64_BIT: return GPU_SAMPLE_COUNT_64_BIT; - default: 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; + case VK_SAMPLE_COUNT_4_BIT: return GPU_SAMPLE_COUNT_4; + case VK_SAMPLE_COUNT_8_BIT: return GPU_SAMPLE_COUNT_8; + case VK_SAMPLE_COUNT_16_BIT: return GPU_SAMPLE_COUNT_16; + case VK_SAMPLE_COUNT_32_BIT: return GPU_SAMPLE_COUNT_32; + case VK_SAMPLE_COUNT_64_BIT: return GPU_SAMPLE_COUNT_64; + 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_DEPTH_BIT) != 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_COLOR) != 0 ? VK_IMAGE_ASPECT_COLOR_BIT : 0; + output |= (aspect & GPU_IMAGE_ASPECT_DEPTH) != 0 ? VK_IMAGE_ASPECT_DEPTH_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_DEPTH_BIT) != 0 ? GPU_IMAGE_ASPECT_DEPTH_BIT : 0; - output |= (aspect & VK_IMAGE_ASPECT_STENCIL_BIT) != 0 ? GPU_IMAGE_ASPECT_STENCIL_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 : 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; +} diff --git a/src/main.c b/src/main.c index c45e292..595afb3 100644 --- a/src/main.c +++ b/src/main.c @@ -121,14 +121,16 @@ i32 main(void) { }; GpuCommandBufferPtrArray buffers = gpuAllocateCommandBuffers(&arena, &temp_arena, buf_alloc_request); - GpuCommandBuffer *cmd = buffers[0]; - gpuBeginCommandBuffer(cmd); - gpuEndCommandBuffer(cmd); + GpuCommandBufferBeginRequest cb_request = { + .command_buffer = buffers[0], + }; + 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,