Implement GPU command wrappers
This commit is contained in:
abdelrahman committed
1 parent
5e8175b224
commit
d35713efdb
3 files changed
+671
-73
No files matched your search
+429
-26
@@ -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;
|
||||
}
|
||||
Reference in new issue
Block a user