vulkan/runtime: add implementation of older entrypoints using KHR_DAC

Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@intel.com>
Reviewed-by: Samuel Pitoiset <samuel.pitoiset@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/40431>
This commit is contained in:
Lionel Landwerlin 2025-03-05 14:35:21 +02:00 committed by Marge Bot
parent b7bf4e5304
commit a8e49be9d9

View file

@ -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);
}