From a8e49be9d94ce229a5603332241ae1ea6b12f4f1 Mon Sep 17 00:00:00 2001 From: Lionel Landwerlin Date: Wed, 5 Mar 2025 14:35:21 +0200 Subject: [PATCH] vulkan/runtime: add implementation of older entrypoints using KHR_DAC Signed-off-by: Lionel Landwerlin Reviewed-by: Samuel Pitoiset Part-of: --- src/vulkan/runtime/vk_command_buffer.c | 599 +++++++++++++++++++++++++ 1 file changed, 599 insertions(+) diff --git a/src/vulkan/runtime/vk_command_buffer.c b/src/vulkan/runtime/vk_command_buffer.c index 486b5d5b005..e9af91398c0 100644 --- a/src/vulkan/runtime/vk_command_buffer.c +++ b/src/vulkan/runtime/vk_command_buffer.c @@ -24,10 +24,13 @@ #include "vk_command_buffer.h" #include "vk_alloc.h" +#include "vk_buffer.h" #include "vk_command_pool.h" #include "vk_common_entrypoints.h" #include "vk_device.h" +#include "vk_util.h" + VkResult vk_command_buffer_init(struct vk_command_pool *pool, struct vk_command_buffer *command_buffer, @@ -375,3 +378,599 @@ vk_common_CmdBindDescriptorBufferEmbeddedSamplersEXT( disp->CmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, &two); } + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdBindIndexBuffer2KHR( + VkCommandBuffer commandBuffer, + VkBuffer _buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, _buffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdBindIndexBuffer3KHR( + commandBuffer, + &(VkBindIndexBuffer3InfoKHR) { + .sType = VK_STRUCTURE_TYPE_BIND_INDEX_BUFFER_3_INFO_KHR, + .addressRange = vk_device_address_range( + buffer, offset, size), + .addressFlags = buffer ? buffer->address_flags : 0, + .indexType = indexType, + }); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdBindVertexBuffers2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + + STACK_ARRAY(VkBindVertexBuffer3InfoKHR, bindings, bindingCount); + + for (uint32_t b = 0; b < bindingCount; b++) { + VK_FROM_HANDLE(vk_buffer, buffer, pBuffers[b]); + + bindings[b] = (VkBindVertexBuffer3InfoKHR) { + .sType = VK_STRUCTURE_TYPE_BIND_VERTEX_BUFFER_3_INFO_KHR, + .addressRange = vk_strided_device_address_range( + buffer, pOffsets[b], + pSizes != NULL ? pSizes[b] : VK_WHOLE_SIZE, + pStrides != NULL ? pStrides[b] : 0), + .addressFlags = buffer ? buffer->address_flags : 0, + .setStride = pStrides != NULL, + }; + } + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdBindVertexBuffers3KHR( + commandBuffer, firstBinding, bindingCount, + bindingCount > 0 ? bindings : NULL); + + STACK_ARRAY_FINISH(bindings); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer _buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, _buffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdDrawIndirect2KHR(commandBuffer, + &(VkDrawIndirect2InfoKHR) { + .sType = VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR, + .addressRange = vk_strided_device_address_range( + buffer, offset, VK_WHOLE_SIZE, stride), + .addressFlags = buffer->address_flags, + .drawCount = drawCount, + }); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer _buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, _buffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdDrawIndexedIndirect2KHR( + commandBuffer, + &(VkDrawIndirect2InfoKHR) { + .sType = VK_STRUCTURE_TYPE_DRAW_INDIRECT_2_INFO_KHR, + .addressRange = vk_strided_device_address_range( + buffer, offset, VK_WHOLE_SIZE, stride), + .addressFlags = buffer->address_flags, + .drawCount = drawCount, + }); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdDrawIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer _buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, _buffer); + VK_FROM_HANDLE(vk_buffer, count_buffer, countBuffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdDrawIndirectCount2KHR( + commandBuffer, + &(VkDrawIndirectCount2InfoKHR) { + .sType = VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR, + .addressRange = vk_strided_device_address_range( + buffer, offset, VK_WHOLE_SIZE, stride), + .addressFlags = buffer->address_flags, + .countAddressRange = vk_device_address_range( + count_buffer, countBufferOffset, VK_WHOLE_SIZE), + .countAddressFlags = count_buffer->address_flags, + .maxDrawCount = maxDrawCount, + }); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdDrawIndexedIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer _buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, _buffer); + VK_FROM_HANDLE(vk_buffer, count_buffer, countBuffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdDrawIndexedIndirectCount2KHR( + commandBuffer, + &(VkDrawIndirectCount2InfoKHR) { + .sType = VK_STRUCTURE_TYPE_DRAW_INDIRECT_COUNT_2_INFO_KHR, + .addressRange = vk_strided_device_address_range( + buffer, offset, VK_WHOLE_SIZE, stride), + .addressFlags = buffer->address_flags, + .countAddressRange = vk_device_address_range( + count_buffer, countBufferOffset, VK_WHOLE_SIZE), + .countAddressFlags = count_buffer->address_flags, + .maxDrawCount = maxDrawCount, + }); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdBeginConditionalRenderingEXT( + VkCommandBuffer commandBuffer, + const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, pConditionalRenderingBegin->buffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdBeginConditionalRendering2EXT( + commandBuffer, + &(VkConditionalRenderingBeginInfo2EXT) { + .sType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_2_EXT, + .addressRange = vk_device_address_range( + buffer, pConditionalRenderingBegin->offset, VK_WHOLE_SIZE), + .flags = pConditionalRenderingBegin->flags, + }); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdBindTransformFeedbackBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + + STACK_ARRAY(VkBindTransformFeedbackBuffer2InfoEXT, bindings, bindingCount); + + for (uint32_t b = 0; b < bindingCount; b++) { + VK_FROM_HANDLE(vk_buffer, buffer, pBuffers[b]); + + bindings[b] = (VkBindTransformFeedbackBuffer2InfoEXT) { + .sType = VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT, + .addressRange = vk_device_address_range( + buffer, pOffsets ? pOffsets[b] : 0, + pSizes ? pSizes[b] : VK_WHOLE_SIZE), + .addressFlags = buffer ? buffer->address_flags : 0, + }; + } + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdBindTransformFeedbackBuffers2EXT( + commandBuffer, firstBinding, bindingCount, + bindingCount > 0 ? bindings : NULL); + + STACK_ARRAY_FINISH(bindings); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdBeginTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + + STACK_ARRAY(VkBindTransformFeedbackBuffer2InfoEXT, buffers, counterBufferCount); + + for (uint32_t b = 0; b < counterBufferCount; b++) { + VK_FROM_HANDLE(vk_buffer, buffer, pCounterBuffers[b]); + + buffers[b] = (VkBindTransformFeedbackBuffer2InfoEXT) { + .sType = VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT, + .addressRange = vk_device_address_range( + buffer, pCounterBufferOffsets ? pCounterBufferOffsets[b] : 0, + VK_WHOLE_SIZE), + .addressFlags = buffer ? buffer->address_flags : 0, + }; + } + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdBeginTransformFeedback2EXT( + commandBuffer, firstCounterBuffer, counterBufferCount, + counterBufferCount > 0 ? buffers : NULL); + + STACK_ARRAY_FINISH(buffers); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdEndTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + + STACK_ARRAY(VkBindTransformFeedbackBuffer2InfoEXT, buffers, counterBufferCount); + + for (uint32_t b = 0; b < counterBufferCount; b++) { + VK_FROM_HANDLE(vk_buffer, buffer, pCounterBuffers[b]); + + buffers[b] = (VkBindTransformFeedbackBuffer2InfoEXT) { + .sType = VK_STRUCTURE_TYPE_BIND_TRANSFORM_FEEDBACK_BUFFER_2_INFO_EXT, + .addressRange = vk_device_address_range( + buffer, pCounterBufferOffsets ? pCounterBufferOffsets[b] : 0, + VK_WHOLE_SIZE), + .addressFlags = buffer ? buffer->address_flags : 0, + }; + } + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdEndTransformFeedback2EXT( + commandBuffer, firstCounterBuffer, counterBufferCount, + counterBufferCount > 0 ? buffers : NULL); + + STACK_ARRAY_FINISH(buffers); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdDrawIndirectByteCountEXT( + VkCommandBuffer commandBuffer, + uint32_t instanceCount, + uint32_t firstInstance, + VkBuffer counterBuffer, + VkDeviceSize counterBufferOffset, + uint32_t counterOffset, + uint32_t vertexStride) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, counterBuffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdDrawIndirectByteCount2EXT( + commandBuffer, instanceCount, firstInstance, + &(VkBindTransformFeedbackBuffer2InfoEXT) { + .addressRange = vk_device_address_range( + buffer, counterBufferOffset, VK_WHOLE_SIZE), + .addressFlags = buffer->address_flags, + }, + counterOffset, + vertexStride); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdDrawMeshTasksIndirectEXT( + VkCommandBuffer commandBuffer, + VkBuffer _buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, _buffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdDrawMeshTasksIndirect2EXT( + commandBuffer, + &(VkDrawIndirect2InfoKHR) { + .addressRange = vk_strided_device_address_range( + buffer, offset, VK_WHOLE_SIZE, stride), + .addressFlags = buffer->address_flags, + .drawCount = drawCount, + }); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdDrawMeshTasksIndirectCountEXT( + VkCommandBuffer commandBuffer, + VkBuffer _buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, _buffer); + VK_FROM_HANDLE(vk_buffer, count_buffer, countBuffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdDrawMeshTasksIndirectCount2EXT( + commandBuffer, + &(VkDrawIndirectCount2InfoKHR) { + .addressRange = vk_strided_device_address_range( + buffer, offset, VK_WHOLE_SIZE, stride), + .addressFlags = buffer->address_flags, + .countAddressRange = vk_device_address_range( + count_buffer, countBufferOffset, VK_WHOLE_SIZE), + .countAddressFlags = count_buffer->address_flags, + .maxDrawCount = maxDrawCount, + }); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdWriteBufferMarker2AMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, dstBuffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdWriteMarkerToMemoryAMD( + commandBuffer, + &(VkMemoryMarkerInfoAMD) { + .sType = VK_STRUCTURE_TYPE_MEMORY_MARKER_INFO_AMD, + .stage = stage, + .dstRange = vk_device_address_range( + buffer, dstOffset, VK_WHOLE_SIZE), + .dstFlags = buffer->address_flags, + .marker = marker, + }); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer _buffer, + VkDeviceSize offset) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, _buffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdDispatchIndirect2KHR( + commandBuffer, + &(VkDispatchIndirect2InfoKHR) { + .sType = VK_STRUCTURE_TYPE_DISPATCH_INDIRECT_2_INFO_KHR, + .addressRange = vk_device_address_range( + buffer, offset, VK_WHOLE_SIZE), + .addressFlags = buffer->address_flags, + }); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdCopyBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2* pCopyBufferInfo) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, src_buffer, pCopyBufferInfo->srcBuffer); + VK_FROM_HANDLE(vk_buffer, dst_buffer, pCopyBufferInfo->dstBuffer); + + STACK_ARRAY(VkDeviceMemoryCopyKHR, regions, pCopyBufferInfo->regionCount); + + for (uint32_t r = 0; r < pCopyBufferInfo->regionCount; r++) { + regions[r] = (VkDeviceMemoryCopyKHR) { + .srcRange = vk_device_address_range( + src_buffer, + pCopyBufferInfo->pRegions[r].srcOffset, + pCopyBufferInfo->pRegions[r].size), + .srcFlags = src_buffer->address_flags, + .dstRange = vk_device_address_range( + dst_buffer, + pCopyBufferInfo->pRegions[r].dstOffset, + pCopyBufferInfo->pRegions[r].size), + .dstFlags = dst_buffer->address_flags, + }; + } + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdCopyMemoryKHR( + commandBuffer, + &(VkCopyDeviceMemoryInfoKHR) { + .sType = VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_INFO_KHR, + .regionCount = pCopyBufferInfo->regionCount, + .pRegions = pCopyBufferInfo->regionCount > 0 ? regions : NULL, + }); + + STACK_ARRAY_FINISH(regions); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdCopyBufferToImage2( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, pCopyBufferToImageInfo->srcBuffer); + + STACK_ARRAY(VkDeviceMemoryImageCopyKHR, regions, + pCopyBufferToImageInfo->regionCount); + + for (uint32_t r = 0; r < pCopyBufferToImageInfo->regionCount; r++) { + regions[r] = (VkDeviceMemoryImageCopyKHR) { + .sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR, + .addressRange = vk_device_address_range( + buffer, pCopyBufferToImageInfo->pRegions[r].bufferOffset, + VK_WHOLE_SIZE), + .addressFlags = buffer->copy_flags, + .addressRowLength = pCopyBufferToImageInfo->pRegions[r].bufferRowLength, + .addressImageHeight = pCopyBufferToImageInfo->pRegions[r].bufferImageHeight, + .imageSubresource = pCopyBufferToImageInfo->pRegions[r].imageSubresource, + .imageOffset = pCopyBufferToImageInfo->pRegions[r].imageOffset, + .imageExtent = pCopyBufferToImageInfo->pRegions[r].imageExtent, + }; + } + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdCopyMemoryToImageKHR( + commandBuffer, + &(VkCopyDeviceMemoryImageInfoKHR) { + .sType = VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR, + .image = pCopyBufferToImageInfo->dstImage, + .regionCount = pCopyBufferToImageInfo->regionCount, + .pRegions = pCopyBufferToImageInfo->regionCount > 0 ? regions : NULL, + }); + + STACK_ARRAY_FINISH(regions); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdCopyImageToBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, pCopyImageToBufferInfo->dstBuffer); + + STACK_ARRAY(VkDeviceMemoryImageCopyKHR, regions, + pCopyImageToBufferInfo->regionCount); + + for (uint32_t r = 0; r < pCopyImageToBufferInfo->regionCount; r++) { + regions[r] = (VkDeviceMemoryImageCopyKHR) { + .sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_IMAGE_COPY_KHR, + .addressRange = vk_device_address_range( + buffer, pCopyImageToBufferInfo->pRegions[r].bufferOffset, + VK_WHOLE_SIZE), + .addressFlags = buffer->address_flags, + .addressRowLength = pCopyImageToBufferInfo->pRegions[r].bufferRowLength, + .addressImageHeight = pCopyImageToBufferInfo->pRegions[r].bufferImageHeight, + .imageSubresource = pCopyImageToBufferInfo->pRegions[r].imageSubresource, + .imageOffset = pCopyImageToBufferInfo->pRegions[r].imageOffset, + .imageExtent = pCopyImageToBufferInfo->pRegions[r].imageExtent, + }; + } + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + disp->CmdCopyMemoryToImageKHR( + commandBuffer, + &(VkCopyDeviceMemoryImageInfoKHR) { + .sType = VK_STRUCTURE_TYPE_COPY_DEVICE_MEMORY_IMAGE_INFO_KHR, + .image = pCopyImageToBufferInfo->srcImage, + .regionCount = pCopyImageToBufferInfo->regionCount, + .pRegions = pCopyImageToBufferInfo->regionCount > 0 ? regions : NULL, + }); + + STACK_ARRAY_FINISH(regions); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, dstBuffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + const VkDeviceAddressRangeKHR addr_range = + vk_device_address_range(buffer, dstOffset, dataSize); + disp->CmdUpdateMemoryKHR(commandBuffer, &addr_range, + buffer->address_flags, dataSize, pData); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, dstBuffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + const VkDeviceAddressRangeKHR addr_range = + vk_device_address_range(buffer, dstOffset, size); + disp->CmdFillMemoryKHR(commandBuffer, &addr_range, + buffer->address_flags, data); +} + +VKAPI_ATTR void VKAPI_CALL +vk_common_CmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags) +{ + VK_FROM_HANDLE(vk_command_buffer, cmd_buffer, commandBuffer); + VK_FROM_HANDLE(vk_buffer, buffer, dstBuffer); + + const struct vk_device_dispatch_table *disp = + &cmd_buffer->base.device->dispatch_table; + + const VkStridedDeviceAddressRangeKHR addr_range = + vk_strided_device_address_range( + buffer, dstOffset, VK_WHOLE_SIZE, stride); + + disp->CmdCopyQueryPoolResultsToMemoryKHR(commandBuffer, queryPool, + firstQuery, queryCount, + &addr_range, + buffer->address_flags, flags); +}