lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-09-12 00:35:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement support for VK_KHR_copy_commands2

Browse Source
This commit is contained in:
baldurk
2020-10-20 12:44:25 +01:00
parent d1bc1c68dc
commit 965535560b
8 changed files with 1475 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files
renderdoc/driver/vulkan/vk_common.h
+28
View File
@@ -668,6 +668,12 @@ enum class VulkanChunk : uint32_t
vkCmdSetStencilTestEnableEXT,
vkCmdSetStencilOpEXT,
CoherentMapWrite,
vkCmdCopyBuffer2KHR,
vkCmdCopyImage2KHR,
vkCmdCopyBufferToImage2KHR,
vkCmdCopyImageToBuffer2KHR,
vkCmdBlitImage2KHR,
vkCmdResolveImage2KHR,
Max,
};
@@ -730,9 +736,12 @@ DECLARE_REFLECTION_STRUCT(VkBindImageMemoryInfo);
DECLARE_REFLECTION_STRUCT(VkBindImageMemorySwapchainInfoKHR);
DECLARE_REFLECTION_STRUCT(VkBindImagePlaneMemoryInfo);
DECLARE_REFLECTION_STRUCT(VkBindSparseInfo);
DECLARE_REFLECTION_STRUCT(VkBlitImageInfo2KHR);
DECLARE_REFLECTION_STRUCT(VkBufferCopy2KHR);
DECLARE_REFLECTION_STRUCT(VkBufferCreateInfo);
DECLARE_REFLECTION_STRUCT(VkBufferDeviceAddressCreateInfoEXT);
DECLARE_REFLECTION_STRUCT(VkBufferDeviceAddressInfo);
DECLARE_REFLECTION_STRUCT(VkBufferImageCopy2KHR);
DECLARE_REFLECTION_STRUCT(VkBufferMemoryBarrier);
DECLARE_REFLECTION_STRUCT(VkBufferMemoryRequirementsInfo2);
DECLARE_REFLECTION_STRUCT(VkBufferOpaqueCaptureAddressCreateInfo);
@@ -745,7 +754,11 @@ DECLARE_REFLECTION_STRUCT(VkCommandBufferInheritanceInfo);
DECLARE_REFLECTION_STRUCT(VkCommandPoolCreateInfo);
DECLARE_REFLECTION_STRUCT(VkComputePipelineCreateInfo);
DECLARE_REFLECTION_STRUCT(VkConditionalRenderingBeginInfoEXT);
DECLARE_REFLECTION_STRUCT(VkCopyBufferInfo2KHR);
DECLARE_REFLECTION_STRUCT(VkCopyBufferToImageInfo2KHR);
DECLARE_REFLECTION_STRUCT(VkCopyDescriptorSet);
DECLARE_REFLECTION_STRUCT(VkCopyImageInfo2KHR);
DECLARE_REFLECTION_STRUCT(VkCopyImageToBufferInfo2KHR);
DECLARE_REFLECTION_STRUCT(VkDebugMarkerMarkerInfoEXT);
DECLARE_REFLECTION_STRUCT(VkDebugMarkerObjectNameInfoEXT);
DECLARE_REFLECTION_STRUCT(VkDebugMarkerObjectTagInfoEXT);
@@ -812,12 +825,15 @@ DECLARE_REFLECTION_STRUCT(VkFramebufferAttachmentsCreateInfo);
DECLARE_REFLECTION_STRUCT(VkFramebufferCreateInfo);
DECLARE_REFLECTION_STRUCT(VkGraphicsPipelineCreateInfo);
DECLARE_REFLECTION_STRUCT(VkHdrMetadataEXT);
DECLARE_REFLECTION_STRUCT(VkImageBlit2KHR);
DECLARE_REFLECTION_STRUCT(VkImageCopy2KHR);
DECLARE_REFLECTION_STRUCT(VkImageCreateInfo);
DECLARE_REFLECTION_STRUCT(VkImageFormatListCreateInfo);
DECLARE_REFLECTION_STRUCT(VkImageFormatProperties2);
DECLARE_REFLECTION_STRUCT(VkImageMemoryBarrier);
DECLARE_REFLECTION_STRUCT(VkImageMemoryRequirementsInfo2);
DECLARE_REFLECTION_STRUCT(VkImagePlaneMemoryRequirementsInfo);
DECLARE_REFLECTION_STRUCT(VkImageResolve2KHR);
DECLARE_REFLECTION_STRUCT(VkImageSparseMemoryRequirementsInfo2);
DECLARE_REFLECTION_STRUCT(VkImageStencilUsageCreateInfo);
DECLARE_REFLECTION_STRUCT(VkImageSwapchainCreateInfoKHR);
@@ -984,6 +1000,7 @@ DECLARE_REFLECTION_STRUCT(VkRenderPassFragmentDensityMapCreateInfoEXT);
DECLARE_REFLECTION_STRUCT(VkRenderPassInputAttachmentAspectCreateInfo);
DECLARE_REFLECTION_STRUCT(VkRenderPassMultiviewCreateInfo);
DECLARE_REFLECTION_STRUCT(VkRenderPassSampleLocationsBeginInfoEXT);
DECLARE_REFLECTION_STRUCT(VkResolveImageInfo2KHR);
DECLARE_REFLECTION_STRUCT(VkSampleLocationsInfoEXT);
DECLARE_REFLECTION_STRUCT(VkSamplerCreateInfo);
DECLARE_REFLECTION_STRUCT(VkSamplerCustomBorderColorCreateInfoEXT);
@@ -1038,7 +1055,10 @@ DECLARE_DESERIALISE_TYPE(VkBindImageMemoryInfo);
DECLARE_DESERIALISE_TYPE(VkBindImageMemorySwapchainInfoKHR);
DECLARE_DESERIALISE_TYPE(VkBindImagePlaneMemoryInfo);
DECLARE_DESERIALISE_TYPE(VkBindSparseInfo);
DECLARE_DESERIALISE_TYPE(VkBlitImageInfo2KHR);
DECLARE_DESERIALISE_TYPE(VkBufferCopy2KHR);
DECLARE_DESERIALISE_TYPE(VkBufferCreateInfo);
DECLARE_DESERIALISE_TYPE(VkBufferImageCopy2KHR);
DECLARE_DESERIALISE_TYPE(VkBufferMemoryBarrier);
DECLARE_DESERIALISE_TYPE(VkBufferMemoryRequirementsInfo2);
DECLARE_DESERIALISE_TYPE(VkBufferOpaqueCaptureAddressCreateInfo);
@@ -1051,7 +1071,11 @@ DECLARE_DESERIALISE_TYPE(VkCommandBufferInheritanceInfo);
DECLARE_DESERIALISE_TYPE(VkCommandPoolCreateInfo);
DECLARE_DESERIALISE_TYPE(VkComputePipelineCreateInfo);
DECLARE_DESERIALISE_TYPE(VkConditionalRenderingBeginInfoEXT);
DECLARE_DESERIALISE_TYPE(VkCopyBufferInfo2KHR);
DECLARE_DESERIALISE_TYPE(VkCopyBufferToImageInfo2KHR);
DECLARE_DESERIALISE_TYPE(VkCopyDescriptorSet);
DECLARE_DESERIALISE_TYPE(VkCopyImageInfo2KHR);
DECLARE_DESERIALISE_TYPE(VkCopyImageToBufferInfo2KHR);
DECLARE_DESERIALISE_TYPE(VkDebugMarkerMarkerInfoEXT);
DECLARE_DESERIALISE_TYPE(VkDebugMarkerObjectNameInfoEXT);
DECLARE_DESERIALISE_TYPE(VkDebugMarkerObjectTagInfoEXT);
@@ -1117,12 +1141,15 @@ DECLARE_DESERIALISE_TYPE(VkFramebufferAttachmentImageInfo);
DECLARE_DESERIALISE_TYPE(VkFramebufferAttachmentsCreateInfo);
DECLARE_DESERIALISE_TYPE(VkFramebufferCreateInfo);
DECLARE_DESERIALISE_TYPE(VkGraphicsPipelineCreateInfo);
DECLARE_DESERIALISE_TYPE(VkImageBlit2KHR);
DECLARE_DESERIALISE_TYPE(VkImageCopy2KHR);
DECLARE_DESERIALISE_TYPE(VkImageCreateInfo);
DECLARE_DESERIALISE_TYPE(VkImageFormatListCreateInfo);
DECLARE_DESERIALISE_TYPE(VkImageFormatProperties2);
DECLARE_DESERIALISE_TYPE(VkImageMemoryBarrier);
DECLARE_DESERIALISE_TYPE(VkImageMemoryRequirementsInfo2);
DECLARE_DESERIALISE_TYPE(VkImagePlaneMemoryRequirementsInfo);
DECLARE_DESERIALISE_TYPE(VkImageResolve2KHR);
DECLARE_DESERIALISE_TYPE(VkImageSparseMemoryRequirementsInfo2);
DECLARE_DESERIALISE_TYPE(VkImageStencilUsageCreateInfo);
DECLARE_DESERIALISE_TYPE(VkImageSwapchainCreateInfoKHR);
@@ -1283,6 +1310,7 @@ DECLARE_DESERIALISE_TYPE(VkRenderPassCreateInfo2);
DECLARE_DESERIALISE_TYPE(VkRenderPassInputAttachmentAspectCreateInfo);
DECLARE_DESERIALISE_TYPE(VkRenderPassMultiviewCreateInfo);
DECLARE_DESERIALISE_TYPE(VkRenderPassSampleLocationsBeginInfoEXT);
DECLARE_DESERIALISE_TYPE(VkResolveImageInfo2KHR);
DECLARE_DESERIALISE_TYPE(VkSampleLocationsInfoEXT);
DECLARE_DESERIALISE_TYPE(VkSamplerCreateInfo);
DECLARE_DESERIALISE_TYPE(VkSamplerCustomBorderColorCreateInfoEXT);
renderdoc/driver/vulkan/vk_core.cpp
+16
View File
@@ -987,6 +987,9 @@ static const VkExtensionProperties supportedExtensions[] = {
{
VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION,
},
{
VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME, VK_KHR_COPY_COMMANDS_2_SPEC_VERSION,
},
{
VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME, VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION,
},
@@ -3214,6 +3217,19 @@ bool WrappedVulkan::ProcessChunk(ReadSerialiser &ser, VulkanChunk chunk)
VK_STENCIL_OP_MAX_ENUM, VK_STENCIL_OP_MAX_ENUM,
VK_STENCIL_OP_MAX_ENUM, VK_COMPARE_OP_MAX_ENUM);
case VulkanChunk::vkCmdCopyBuffer2KHR:
return Serialise_vkCmdCopyBuffer2KHR(ser, VK_NULL_HANDLE, NULL);
case VulkanChunk::vkCmdCopyImage2KHR:
return Serialise_vkCmdCopyImage2KHR(ser, VK_NULL_HANDLE, NULL);
case VulkanChunk::vkCmdCopyBufferToImage2KHR:
return Serialise_vkCmdCopyBufferToImage2KHR(ser, VK_NULL_HANDLE, NULL);
case VulkanChunk::vkCmdCopyImageToBuffer2KHR:
return Serialise_vkCmdCopyImageToBuffer2KHR(ser, VK_NULL_HANDLE, NULL);
case VulkanChunk::vkCmdBlitImage2KHR:
return Serialise_vkCmdBlitImage2KHR(ser, VK_NULL_HANDLE, NULL);
case VulkanChunk::vkCmdResolveImage2KHR:
return Serialise_vkCmdResolveImage2KHR(ser, VK_NULL_HANDLE, NULL);
// chunks that are reserved but not yet serialised
case VulkanChunk::vkResetCommandPool:
case VulkanChunk::vkCreateDepthTargetView:
renderdoc/driver/vulkan/vk_core.h
+14
View File
@@ -2387,4 +2387,18 @@ public:
IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdSetStencilOpEXT, VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp,
VkStencilOp depthFailOp, VkCompareOp compareOp);
// VK_KHR_copy_commands2
IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyBuffer2KHR, VkCommandBuffer commandBuffer,
const VkCopyBufferInfo2KHR *pCopyBufferInfo);
IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyImage2KHR, VkCommandBuffer commandBuffer,
const VkCopyImageInfo2KHR *pCopyImageInfo);
IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyBufferToImage2KHR, VkCommandBuffer commandBuffer,
const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo);
IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdCopyImageToBuffer2KHR, VkCommandBuffer commandBuffer,
const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo);
IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBlitImage2KHR, VkCommandBuffer commandBuffer,
const VkBlitImageInfo2KHR *pBlitImageInfo);
IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdResolveImage2KHR, VkCommandBuffer commandBuffer,
const VkResolveImageInfo2KHR *pResolveImageInfo);
};
renderdoc/driver/vulkan/vk_hookset_defs.h
+22 -2
View File
@@ -525,7 +525,8 @@
DeclExt(EXT_robustness2); \
DeclExt(EXT_pipeline_creation_cache_control); \
DeclExt(EXT_private_data); \
DeclExt(EXT_extended_dynamic_state);
DeclExt(EXT_extended_dynamic_state); \
DeclExt(KHR_copy_commands2);
// for simplicity and since the check itself is platform agnostic,
// these aren't protected in platform defines
@@ -623,7 +624,8 @@
CheckExt(EXT_robustness2, VKXX); \
CheckExt(EXT_pipeline_creation_cache_control, VKXX); \
CheckExt(EXT_private_data, VKXX); \
CheckExt(EXT_extended_dynamic_state, VKXX);
CheckExt(EXT_extended_dynamic_state, VKXX); \
CheckExt(KHR_copy_commands2, VKXX);
#define HookInitVulkanInstanceExts_PhysDev() \
HookInitExtension(KHR_surface, GetPhysicalDeviceSurfaceSupportKHR); \
@@ -851,6 +853,12 @@
HookInitExtension(EXT_extended_dynamic_state, CmdSetDepthBoundsTestEnableEXT); \
HookInitExtension(EXT_extended_dynamic_state, CmdSetStencilTestEnableEXT); \
HookInitExtension(EXT_extended_dynamic_state, CmdSetStencilOpEXT); \
HookInitExtension(KHR_copy_commands2, CmdCopyBuffer2KHR); \
HookInitExtension(KHR_copy_commands2, CmdCopyImage2KHR); \
HookInitExtension(KHR_copy_commands2, CmdCopyBufferToImage2KHR); \
HookInitExtension(KHR_copy_commands2, CmdCopyImageToBuffer2KHR); \
HookInitExtension(KHR_copy_commands2, CmdBlitImage2KHR); \
HookInitExtension(KHR_copy_commands2, CmdResolveImage2KHR); \
HookInitExtension_Device_Win32(); \
HookInitExtension_Device_Linux(); \
HookInitExtension_Device_GGP(); \
@@ -1507,6 +1515,18 @@
HookDefine6(void, vkCmdSetStencilOpEXT, VkCommandBuffer, commandBuffer, VkStencilFaceFlags, \
faceMask, VkStencilOp, failOp, VkStencilOp, passOp, VkStencilOp, depthFailOp, \
VkCompareOp, compareOp); \
HookDefine2(void, vkCmdCopyBuffer2KHR, VkCommandBuffer, commandBuffer, \
const VkCopyBufferInfo2KHR *, pCopyBufferInfo); \
HookDefine2(void, vkCmdCopyImage2KHR, VkCommandBuffer, commandBuffer, \
const VkCopyImageInfo2KHR *, pCopyImageInfo); \
HookDefine2(void, vkCmdCopyBufferToImage2KHR, VkCommandBuffer, commandBuffer, \
const VkCopyBufferToImageInfo2KHR *, pCopyBufferToImageInfo); \
HookDefine2(void, vkCmdCopyImageToBuffer2KHR, VkCommandBuffer, commandBuffer, \
const VkCopyImageToBufferInfo2KHR *, pCopyImageToBufferInfo); \
HookDefine2(void, vkCmdBlitImage2KHR, VkCommandBuffer, commandBuffer, \
const VkBlitImageInfo2KHR *, pBlitImageInfo); \
HookDefine2(void, vkCmdResolveImage2KHR, VkCommandBuffer, commandBuffer, \
const VkResolveImageInfo2KHR *, pResolveImageInfo); \
HookDefine_Win32(); \
HookDefine_Linux(); \
HookDefine_GGP(); \
renderdoc/driver/vulkan/vk_next_chains.cpp
+324 -32
View File
@@ -53,6 +53,19 @@ static void CopyNextChainedStruct(const size_t structSize, byte *&tempMem,
nextChainTail = outstruct;
}
// create a copy of the struct in temporary memory. Mostly only useful for when we're setting up a
// recursive next chain unwrap
template <typename VkStruct>
static VkStruct *AllocStructCopy(byte *&tempMem, const VkStruct *inputStruct)
{
VkStruct *ret = (VkStruct *)tempMem;
tempMem = (byte *)(ret + 1);
*ret = *inputStruct;
return ret;
}
// this is similar to the above function, but for use after we've modified a struct locally
// e.g. to unwrap some members or patch flags, etc.
template <typename VkStruct>
@@ -84,9 +97,11 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
COPY_STRUCT(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, \
VkBindImageMemoryDeviceGroupInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, VkBindImagePlaneMemoryInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR, VkBufferCopy2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, VkBufferCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT, \
VkBufferDeviceAddressCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR, VkBufferImageCopy2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, \
VkBufferOpaqueCaptureAddressCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT, VkCalibratedTimestampInfoEXT); \
@@ -148,11 +163,14 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
VkFramebufferAttachmentsCreateInfo) \
COPY_STRUCT(VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, VkFramebufferAttachmentImageInfo) \
COPY_STRUCT(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, VkFormatProperties2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR, VkImageBlit2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR, VkImageCopy2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, VkImageCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, VkImageFormatListCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, VkImageFormatProperties2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, \
VkImagePlaneMemoryRequirementsInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR, VkImageResolve2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, VkImageStencilUsageCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT, VkImageViewASTCDecodeModeEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, VkImageViewUsageCreateInfo); \
@@ -586,18 +604,11 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_KHR: \
case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR: \
case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_KHR: \
case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR: \
case VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR: \
case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR: \
case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV: \
case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: \
case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV: \
case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR: \
case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: \
case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR: \
case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR: \
case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR: \
case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR: \
case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: \
case VK_STRUCTURE_TYPE_DEFERRED_OPERATION_INFO_KHR: \
case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: \
@@ -616,12 +627,9 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_HDR_METADATA_EXT: \
case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT: \
case VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR: \
case VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR: \
case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: \
case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: \
case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: \
case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR: \
case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: \
case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: \
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: \
@@ -697,7 +705,6 @@ static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: \
case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: \
case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR: \
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: \
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: \
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: \
@@ -756,6 +763,56 @@ size_t GetNextPatchSize(const void *pNext)
memSize += info->pImageBinds[i].bindCount * sizeof(VkSparseImageMemoryBind);
break;
}
case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR:
{
memSize += sizeof(VkBlitImageInfo2KHR);
VkBlitImageInfo2KHR *info = (VkBlitImageInfo2KHR *)next;
memSize += info->regionCount * sizeof(VkImageBlit2KHR);
for(uint32_t i = 0; i < info->regionCount; i++)
memSize += GetNextPatchSize(info->pRegions[i].pNext);
break;
}
case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
{
memSize += sizeof(VkComputePipelineCreateInfo);
break;
}
case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR:
{
memSize += sizeof(VkCopyBufferInfo2KHR);
VkCopyBufferInfo2KHR *info = (VkCopyBufferInfo2KHR *)next;
memSize += info->regionCount * sizeof(VkBufferCopy2KHR);
for(uint32_t i = 0; i < info->regionCount; i++)
memSize += GetNextPatchSize(info->pRegions[i].pNext);
break;
}
case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR:
{
memSize += sizeof(VkCopyBufferToImageInfo2KHR);
VkCopyBufferToImageInfo2KHR *info = (VkCopyBufferToImageInfo2KHR *)next;
memSize += info->regionCount * sizeof(VkBufferImageCopy2KHR);
for(uint32_t i = 0; i < info->regionCount; i++)
memSize += GetNextPatchSize(info->pRegions[i].pNext);
break;
}
case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR:
{
memSize += sizeof(VkCopyImageToBufferInfo2KHR);
VkCopyImageToBufferInfo2KHR *info = (VkCopyImageToBufferInfo2KHR *)next;
memSize += info->regionCount * sizeof(VkBufferImageCopy2KHR);
for(uint32_t i = 0; i < info->regionCount; i++)
memSize += GetNextPatchSize(info->pRegions[i].pNext);
break;
}
case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR:
{
memSize += sizeof(VkCopyImageInfo2KHR);
VkCopyImageInfo2KHR *info = (VkCopyImageInfo2KHR *)next;
memSize += info->regionCount * sizeof(VkImageCopy2KHR);
for(uint32_t i = 0; i < info->regionCount; i++)
memSize += GetNextPatchSize(info->pRegions[i].pNext);
break;
}
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
{
memSize += sizeof(VkDescriptorSetAllocateInfo);
@@ -798,11 +855,28 @@ size_t GetNextPatchSize(const void *pNext)
VkGraphicsPipelineCreateInfo *info = (VkGraphicsPipelineCreateInfo *)next;
memSize += info->stageCount * sizeof(VkPipelineShaderStageCreateInfo);
break;
}
case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
{
memSize += sizeof(VkComputePipelineCreateInfo);
for(uint32_t s = 0; s < info->stageCount; s++)
memSize += GetNextPatchSize(info->pStages[s].pNext);
// need to copy the base struct of each of these so we can potentially patch pNext inside it
memSize += sizeof(*info->pVertexInputState);
memSize += GetNextPatchSize(info->pVertexInputState->pNext);
memSize += sizeof(*info->pInputAssemblyState);
memSize += GetNextPatchSize(info->pInputAssemblyState->pNext);
memSize += sizeof(*info->pTessellationState);
memSize += GetNextPatchSize(info->pTessellationState->pNext);
memSize += sizeof(*info->pViewportState);
memSize += GetNextPatchSize(info->pViewportState->pNext);
memSize += sizeof(*info->pRasterizationState);
memSize += GetNextPatchSize(info->pRasterizationState->pNext);
memSize += sizeof(*info->pMultisampleState);
memSize += GetNextPatchSize(info->pMultisampleState->pNext);
memSize += sizeof(*info->pDepthStencilState);
memSize += GetNextPatchSize(info->pDepthStencilState->pNext);
memSize += sizeof(*info->pColorBlendState);
memSize += GetNextPatchSize(info->pColorBlendState->pNext);
memSize += sizeof(*info->pDynamicState);
memSize += GetNextPatchSize(info->pDynamicState->pNext);
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
@@ -830,6 +904,15 @@ size_t GetNextPatchSize(const void *pNext)
memSize += info->attachmentCount * sizeof(VkImageView);
break;
}
case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR:
{
memSize += sizeof(VkResolveImageInfo2KHR);
VkResolveImageInfo2KHR *info = (VkResolveImageInfo2KHR *)next;
memSize += info->regionCount * sizeof(VkImageResolve2KHR);
for(uint32_t i = 0; i < info->regionCount; i++)
memSize += GetNextPatchSize(info->pRegions[i].pNext);
break;
}
case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO:
{
memSize += sizeof(VkSemaphoreWaitInfo);
@@ -1167,6 +1250,148 @@ void UnwrapNextChain(CaptureState state, const char *structName, byte *&tempMem,
break;
}
case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR:
{
const VkBlitImageInfo2KHR *in = (const VkBlitImageInfo2KHR *)nextInput;
VkBlitImageInfo2KHR *out = (VkBlitImageInfo2KHR *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkImageBlit2KHR *outRegions = (VkImageBlit2KHR *)tempMem;
tempMem += sizeof(VkImageBlit2KHR) * in->regionCount;
*out = *in;
UnwrapInPlace(out->srcImage);
UnwrapInPlace(out->dstImage);
out->pRegions = outRegions;
for(uint32_t i = 0; i < in->regionCount; i++)
{
outRegions[i] = in->pRegions[i];
UnwrapNextChain(state, "VkImageBlit2KHR", tempMem, (VkBaseInStructure *)&outRegions[i]);
}
break;
}
case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
{
const VkComputePipelineCreateInfo *in = (const VkComputePipelineCreateInfo *)nextInput;
VkComputePipelineCreateInfo *out = (VkComputePipelineCreateInfo *)tempMem;
*out = *in;
UnwrapInPlace(out->layout);
UnwrapInPlace(out->stage.module);
if(out->flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
UnwrapInPlace(out->basePipelineHandle);
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
break;
}
case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR:
{
const VkCopyBufferInfo2KHR *in = (const VkCopyBufferInfo2KHR *)nextInput;
VkCopyBufferInfo2KHR *out = (VkCopyBufferInfo2KHR *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkBufferCopy2KHR *outRegions = (VkBufferCopy2KHR *)tempMem;
tempMem += sizeof(VkBufferCopy2KHR) * in->regionCount;
*out = *in;
UnwrapInPlace(out->srcBuffer);
UnwrapInPlace(out->dstBuffer);
out->pRegions = outRegions;
for(uint32_t i = 0; i < in->regionCount; i++)
{
outRegions[i] = in->pRegions[i];
UnwrapNextChain(state, "VkBufferCopy2KHR", tempMem, (VkBaseInStructure *)&outRegions[i]);
}
break;
}
case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR:
{
const VkCopyBufferToImageInfo2KHR *in = (const VkCopyBufferToImageInfo2KHR *)nextInput;
VkCopyBufferToImageInfo2KHR *out = (VkCopyBufferToImageInfo2KHR *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkBufferImageCopy2KHR *outRegions = (VkBufferImageCopy2KHR *)tempMem;
tempMem += sizeof(VkBufferImageCopy2KHR) * in->regionCount;
*out = *in;
UnwrapInPlace(out->srcBuffer);
UnwrapInPlace(out->dstImage);
out->pRegions = outRegions;
for(uint32_t i = 0; i < in->regionCount; i++)
{
outRegions[i] = in->pRegions[i];
UnwrapNextChain(state, "VkBufferImageCopy2KHR", tempMem,
(VkBaseInStructure *)&outRegions[i]);
}
break;
}
case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR:
{
const VkCopyImageToBufferInfo2KHR *in = (const VkCopyImageToBufferInfo2KHR *)nextInput;
VkCopyImageToBufferInfo2KHR *out = (VkCopyImageToBufferInfo2KHR *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkBufferImageCopy2KHR *outRegions = (VkBufferImageCopy2KHR *)tempMem;
tempMem += sizeof(VkBufferImageCopy2KHR) * in->regionCount;
*out = *in;
UnwrapInPlace(out->srcImage);
UnwrapInPlace(out->dstBuffer);
out->pRegions = outRegions;
for(uint32_t i = 0; i < in->regionCount; i++)
{
outRegions[i] = in->pRegions[i];
UnwrapNextChain(state, "VkBufferImageCopy2KHR", tempMem,
(VkBaseInStructure *)&outRegions[i]);
}
break;
}
case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR:
{
const VkCopyImageInfo2KHR *in = (const VkCopyImageInfo2KHR *)nextInput;
VkCopyImageInfo2KHR *out = (VkCopyImageInfo2KHR *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkImageCopy2KHR *outRegions = (VkImageCopy2KHR *)tempMem;
tempMem += sizeof(VkImageCopy2KHR) * in->regionCount;
*out = *in;
UnwrapInPlace(out->srcImage);
UnwrapInPlace(out->dstImage);
out->pRegions = outRegions;
for(uint32_t i = 0; i < in->regionCount; i++)
{
outRegions[i] = in->pRegions[i];
UnwrapNextChain(state, "VkImageCopy2KHR", tempMem, (VkBaseInStructure *)&outRegions[i]);
}
break;
}
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
{
const VkDescriptorSetAllocateInfo *in = (const VkDescriptorSetAllocateInfo *)nextInput;
@@ -1279,30 +1504,54 @@ void UnwrapNextChain(CaptureState state, const char *structName, byte *&tempMem,
VkPipelineShaderStageCreateInfo *outShaders = (VkPipelineShaderStageCreateInfo *)tempMem;
tempMem += sizeof(VkPipelineShaderStageCreateInfo) * in->stageCount;
*out = *in;
UnwrapInPlace(out->layout);
UnwrapInPlace(out->renderPass);
if(out->flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
UnwrapInPlace(out->basePipelineHandle);
out->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
out->pNext = in->pNext;
out->flags = in->flags;
out->stageCount = in->stageCount;
out->pStages = outShaders;
for(uint32_t i = 0; i < in->stageCount; i++)
{
outShaders[i].module = Unwrap(in->pStages[i].module);
UnwrapNextChain(state, "VkPipelineShaderStageCreateInfo", tempMem,
(VkBaseInStructure *)&outShaders[i]);
}
break;
}
case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
{
const VkComputePipelineCreateInfo *in = (const VkComputePipelineCreateInfo *)nextInput;
VkComputePipelineCreateInfo *out = (VkComputePipelineCreateInfo *)tempMem;
out->pVertexInputState = AllocStructCopy(tempMem, in->pVertexInputState);
UnwrapNextChain(state, "VkPipelineVertexInputStateCreateInfo", tempMem,
(VkBaseInStructure *)out->pVertexInputState);
out->pInputAssemblyState = AllocStructCopy(tempMem, in->pInputAssemblyState);
UnwrapNextChain(state, "VkPipelineInputAssemblyStateCreateInfo", tempMem,
(VkBaseInStructure *)out->pInputAssemblyState);
out->pTessellationState = AllocStructCopy(tempMem, in->pTessellationState);
UnwrapNextChain(state, "VkPipelineTessellationStateCreateInfo", tempMem,
(VkBaseInStructure *)out->pTessellationState);
out->pViewportState = AllocStructCopy(tempMem, in->pViewportState);
UnwrapNextChain(state, "VkPipelineViewportStateCreateInfo", tempMem,
(VkBaseInStructure *)out->pViewportState);
out->pRasterizationState = AllocStructCopy(tempMem, in->pRasterizationState);
UnwrapNextChain(state, "VkPipelineRasterizationStateCreateInfo", tempMem,
(VkBaseInStructure *)out->pRasterizationState);
out->pMultisampleState = AllocStructCopy(tempMem, in->pMultisampleState);
UnwrapNextChain(state, "VkPipelineMultisampleStateCreateInfo", tempMem,
(VkBaseInStructure *)out->pMultisampleState);
out->pDepthStencilState = AllocStructCopy(tempMem, in->pDepthStencilState);
UnwrapNextChain(state, "VkPipelineDepthStencilStateCreateInfo", tempMem,
(VkBaseInStructure *)out->pDepthStencilState);
out->pColorBlendState = AllocStructCopy(tempMem, in->pColorBlendState);
UnwrapNextChain(state, "VkPipelineColorBlendStateCreateInfo", tempMem,
(VkBaseInStructure *)out->pColorBlendState);
out->pDynamicState = AllocStructCopy(tempMem, in->pDynamicState);
UnwrapNextChain(state, "VkPipelineDynamicStateCreateInfo", tempMem,
(VkBaseInStructure *)out->pDynamicState);
*out = *in;
UnwrapInPlace(out->layout);
UnwrapInPlace(out->stage.module);
UnwrapInPlace(out->renderPass);
out->subpass = in->subpass;
if(out->flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
UnwrapInPlace(out->basePipelineHandle);
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
else
out->basePipelineHandle = VK_NULL_HANDLE;
out->basePipelineIndex = in->basePipelineIndex;
break;
}
@@ -1372,6 +1621,31 @@ void UnwrapNextChain(CaptureState state, const char *structName, byte *&tempMem,
break;
}
case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR:
{
const VkResolveImageInfo2KHR *in = (const VkResolveImageInfo2KHR *)nextInput;
VkResolveImageInfo2KHR *out = (VkResolveImageInfo2KHR *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkImageResolve2KHR *outRegions = (VkImageResolve2KHR *)tempMem;
tempMem += sizeof(VkImageResolve2KHR) * in->regionCount;
*out = *in;
UnwrapInPlace(out->srcImage);
UnwrapInPlace(out->dstImage);
out->pRegions = outRegions;
for(uint32_t i = 0; i < in->regionCount; i++)
{
outRegions[i] = in->pRegions[i];
UnwrapNextChain(state, "VkImageResolve2KHR", tempMem, (VkBaseInStructure *)&outRegions[i]);
}
break;
}
case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO:
{
const VkSemaphoreWaitInfo *in = (const VkSemaphoreWaitInfo *)nextInput;
@@ -1690,6 +1964,21 @@ void CopyNextChainForPatching(const char *structName, byte *&tempMem, VkBaseInSt
case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
CopyNextChainedStruct(sizeof(VkBindSparseInfo), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR:
CopyNextChainedStruct(sizeof(VkBlitImageInfo2KHR), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR:
CopyNextChainedStruct(sizeof(VkCopyBufferInfo2KHR), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR:
CopyNextChainedStruct(sizeof(VkCopyBufferToImageInfo2KHR), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR:
CopyNextChainedStruct(sizeof(VkCopyImageToBufferInfo2KHR), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR:
CopyNextChainedStruct(sizeof(VkCopyImageInfo2KHR), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
CopyNextChainedStruct(sizeof(VkDescriptorSetAllocateInfo), tempMem, nextInput, nextChainTail);
break;
@@ -1721,6 +2010,9 @@ void CopyNextChainForPatching(const char *structName, byte *&tempMem, VkBaseInSt
CopyNextChainedStruct(sizeof(VkRenderPassAttachmentBeginInfo), tempMem, nextInput,
nextChainTail);
break;
case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR:
CopyNextChainedStruct(sizeof(VkResolveImageInfo2KHR), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO:
CopyNextChainedStruct(sizeof(VkSemaphoreWaitInfo), tempMem, nextInput, nextChainTail);
break;
renderdoc/driver/vulkan/vk_serialise.cpp
+240 -13
View File
@@ -767,6 +767,19 @@ SERIALISE_VK_HANDLES();
PNEXT_STRUCT(VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, \
VkDeviceMemoryOpaqueCaptureAddressInfo) \
\
/* VK_KHR_copy_commands2 */ \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR, VkBlitImageInfo2KHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR, VkBufferCopy2KHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR, VkBufferImageCopy2KHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR, VkCopyBufferInfo2KHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR, VkCopyBufferToImageInfo2KHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR, VkCopyImageInfo2KHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR, VkCopyImageToBufferInfo2KHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR, VkImageBlit2KHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR, VkImageCopy2KHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR, VkImageResolve2KHR) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR, VkResolveImageInfo2KHR) \
\
/* VK_KHR_create_renderpass2 */ \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, VkAttachmentDescription2) \
PNEXT_STRUCT(VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, VkAttachmentReference2) \
@@ -1142,19 +1155,6 @@ SERIALISE_VK_HANDLES();
/* VK_INTEL_shader_integer_functions2 */ \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL) \
\
/* VK_KHR_copy_commands2 */ \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR) \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR) \
\
/* VK_KHR_deferred_host_operations */ \
PNEXT_UNSUPPORTED(VK_STRUCTURE_TYPE_DEFERRED_OPERATION_INFO_KHR) \
\
@@ -6019,6 +6019,222 @@ void Deserialise(const VkPipelineRasterizationStateStreamCreateInfoEXT &el)
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkBufferCopy2KHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(srcOffset);
SERIALISE_MEMBER(dstOffset);
SERIALISE_MEMBER(size);
}
template <>
void Deserialise(const VkBufferCopy2KHR &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkCopyBufferInfo2KHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(srcBuffer);
SERIALISE_MEMBER(dstBuffer);
SERIALISE_MEMBER(regionCount);
SERIALISE_MEMBER_ARRAY(pRegions, regionCount);
}
template <>
void Deserialise(const VkCopyBufferInfo2KHR &el)
{
DeserialiseNext(el.pNext);
delete[] el.pRegions;
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkImageCopy2KHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(srcSubresource);
SERIALISE_MEMBER(srcOffset);
SERIALISE_MEMBER(dstSubresource);
SERIALISE_MEMBER(dstOffset);
SERIALISE_MEMBER(extent);
}
template <>
void Deserialise(const VkImageCopy2KHR &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkCopyImageInfo2KHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(srcImage);
SERIALISE_MEMBER(srcImageLayout);
SERIALISE_MEMBER(dstImage);
SERIALISE_MEMBER(dstImageLayout);
SERIALISE_MEMBER(regionCount);
SERIALISE_MEMBER_ARRAY(pRegions, regionCount);
}
template <>
void Deserialise(const VkCopyImageInfo2KHR &el)
{
DeserialiseNext(el.pNext);
delete[] el.pRegions;
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkBufferImageCopy2KHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(bufferOffset);
SERIALISE_MEMBER(bufferRowLength);
SERIALISE_MEMBER(bufferImageHeight);
SERIALISE_MEMBER(imageSubresource);
SERIALISE_MEMBER(imageOffset);
SERIALISE_MEMBER(imageExtent);
}
template <>
void Deserialise(const VkBufferImageCopy2KHR &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkCopyBufferToImageInfo2KHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(srcBuffer);
SERIALISE_MEMBER(dstImage);
SERIALISE_MEMBER(dstImageLayout);
SERIALISE_MEMBER(regionCount);
SERIALISE_MEMBER_ARRAY(pRegions, regionCount);
}
template <>
void Deserialise(const VkCopyBufferToImageInfo2KHR &el)
{
DeserialiseNext(el.pNext);
delete[] el.pRegions;
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkCopyImageToBufferInfo2KHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(srcImage);
SERIALISE_MEMBER(srcImageLayout);
SERIALISE_MEMBER(dstBuffer);
SERIALISE_MEMBER(regionCount);
SERIALISE_MEMBER_ARRAY(pRegions, regionCount);
}
template <>
void Deserialise(const VkCopyImageToBufferInfo2KHR &el)
{
DeserialiseNext(el.pNext);
delete[] el.pRegions;
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkImageBlit2KHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(srcSubresource);
SERIALISE_MEMBER(srcOffsets);
SERIALISE_MEMBER(dstSubresource);
SERIALISE_MEMBER(dstOffsets);
}
template <>
void Deserialise(const VkImageBlit2KHR &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkBlitImageInfo2KHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(srcImage);
SERIALISE_MEMBER(srcImageLayout);
SERIALISE_MEMBER(dstImage);
SERIALISE_MEMBER(dstImageLayout);
SERIALISE_MEMBER(regionCount);
SERIALISE_MEMBER_ARRAY(pRegions, regionCount);
SERIALISE_MEMBER(filter);
}
template <>
void Deserialise(const VkBlitImageInfo2KHR &el)
{
DeserialiseNext(el.pNext);
delete[] el.pRegions;
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkImageResolve2KHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(srcSubresource);
SERIALISE_MEMBER(srcOffset);
SERIALISE_MEMBER(dstSubresource);
SERIALISE_MEMBER(dstOffset);
SERIALISE_MEMBER(extent);
}
template <>
void Deserialise(const VkImageResolve2KHR &el)
{
DeserialiseNext(el.pNext);
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkResolveImageInfo2KHR &el)
{
RDCASSERT(ser.IsReading() || el.sType == VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR);
SerialiseNext(ser, el.sType, el.pNext);
SERIALISE_MEMBER(srcImage);
SERIALISE_MEMBER(srcImageLayout);
SERIALISE_MEMBER(dstImage);
SERIALISE_MEMBER(dstImageLayout);
SERIALISE_MEMBER(regionCount);
SERIALISE_MEMBER_ARRAY(pRegions, regionCount);
}
template <>
void Deserialise(const VkResolveImageInfo2KHR &el)
{
DeserialiseNext(el.pNext);
delete[] el.pRegions;
}
template <typename SerialiserType>
void DoSerialise(SerialiserType &ser, VkAttachmentDescription2 &el)
{
@@ -8524,9 +8740,12 @@ INSTANTIATE_SERIALISE_TYPE(VkBindImageMemoryInfo);
INSTANTIATE_SERIALISE_TYPE(VkBindImageMemorySwapchainInfoKHR);
INSTANTIATE_SERIALISE_TYPE(VkBindImagePlaneMemoryInfo);
INSTANTIATE_SERIALISE_TYPE(VkBindSparseInfo);
INSTANTIATE_SERIALISE_TYPE(VkBlitImageInfo2KHR);
INSTANTIATE_SERIALISE_TYPE(VkBufferCopy2KHR);
INSTANTIATE_SERIALISE_TYPE(VkBufferCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkBufferDeviceAddressCreateInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkBufferDeviceAddressInfo);
INSTANTIATE_SERIALISE_TYPE(VkBufferImageCopy2KHR);
INSTANTIATE_SERIALISE_TYPE(VkBufferMemoryBarrier);
INSTANTIATE_SERIALISE_TYPE(VkBufferMemoryRequirementsInfo2);
INSTANTIATE_SERIALISE_TYPE(VkBufferOpaqueCaptureAddressCreateInfo);
@@ -8539,7 +8758,11 @@ INSTANTIATE_SERIALISE_TYPE(VkCommandBufferInheritanceInfo);
INSTANTIATE_SERIALISE_TYPE(VkCommandPoolCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkComputePipelineCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkConditionalRenderingBeginInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkCopyBufferInfo2KHR);
INSTANTIATE_SERIALISE_TYPE(VkCopyBufferToImageInfo2KHR);
INSTANTIATE_SERIALISE_TYPE(VkCopyDescriptorSet);
INSTANTIATE_SERIALISE_TYPE(VkCopyImageInfo2KHR);
INSTANTIATE_SERIALISE_TYPE(VkCopyImageToBufferInfo2KHR);
INSTANTIATE_SERIALISE_TYPE(VkDebugMarkerMarkerInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkDebugMarkerObjectNameInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkDebugMarkerObjectTagInfoEXT);
@@ -8605,12 +8828,15 @@ INSTANTIATE_SERIALISE_TYPE(VkFramebufferAttachmentsCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkFramebufferCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkGraphicsPipelineCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkHdrMetadataEXT);
INSTANTIATE_SERIALISE_TYPE(VkImageBlit2KHR);
INSTANTIATE_SERIALISE_TYPE(VkImageCopy2KHR);
INSTANTIATE_SERIALISE_TYPE(VkImageCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkImageFormatListCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkImageFormatProperties2);
INSTANTIATE_SERIALISE_TYPE(VkImageMemoryBarrier);
INSTANTIATE_SERIALISE_TYPE(VkImageMemoryRequirementsInfo2);
INSTANTIATE_SERIALISE_TYPE(VkImagePlaneMemoryRequirementsInfo);
INSTANTIATE_SERIALISE_TYPE(VkImageResolve2KHR);
INSTANTIATE_SERIALISE_TYPE(VkImageSparseMemoryRequirementsInfo2);
INSTANTIATE_SERIALISE_TYPE(VkImageStencilUsageCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkImageSwapchainCreateInfoKHR);
@@ -8775,6 +9001,7 @@ INSTANTIATE_SERIALISE_TYPE(VkRenderPassFragmentDensityMapCreateInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkRenderPassInputAttachmentAspectCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkRenderPassMultiviewCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkRenderPassSampleLocationsBeginInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkResolveImageInfo2KHR);
INSTANTIATE_SERIALISE_TYPE(VkSampleLocationsInfoEXT);
INSTANTIATE_SERIALISE_TYPE(VkSamplerCreateInfo);
INSTANTIATE_SERIALISE_TYPE(VkSamplerCustomBorderColorCreateInfoEXT);
renderdoc/driver/vulkan/vk_stringise.cpp
+7 -1
View File
@@ -28,7 +28,7 @@
template <>
rdcstr DoStringise(const VulkanChunk &el)
{
RDCCOMPILE_ASSERT((uint32_t)VulkanChunk::Max == 1153, "Chunks changed without updating names");
RDCCOMPILE_ASSERT((uint32_t)VulkanChunk::Max == 1159, "Chunks changed without updating names");
BEGIN_ENUM_STRINGISE(VulkanChunk)
{
@@ -185,6 +185,12 @@ rdcstr DoStringise(const VulkanChunk &el)
STRINGISE_ENUM_CLASS(vkCmdSetStencilTestEnableEXT);
STRINGISE_ENUM_CLASS(vkCmdSetStencilOpEXT);
STRINGISE_ENUM_CLASS_NAMED(CoherentMapWrite, "Internal: Coherent Mapped Memory Write")
STRINGISE_ENUM_CLASS(vkCmdCopyBuffer2KHR);
STRINGISE_ENUM_CLASS(vkCmdCopyImage2KHR);
STRINGISE_ENUM_CLASS(vkCmdCopyBufferToImage2KHR);
STRINGISE_ENUM_CLASS(vkCmdCopyImageToBuffer2KHR);
STRINGISE_ENUM_CLASS(vkCmdBlitImage2KHR);
STRINGISE_ENUM_CLASS(vkCmdResolveImage2KHR);
STRINGISE_ENUM_CLASS_NAMED(Max, "Max Chunk");
}
END_ENUM_STRINGISE()
renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp
+824 -12
View File
@@ -1486,22 +1486,22 @@ void WrappedVulkan::vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcIma
ImageRange srcRange(region.srcSubresource);
srcRange.offset = {std::min(region.srcOffsets[0].x, region.srcOffsets[1].x),
std::min(region.srcOffsets[0].y, region.srcOffsets[1].y),
std::min(region.srcOffsets[0].z, region.srcOffsets[1].z)};
srcRange.offset = {RDCMIN(region.srcOffsets[0].x, region.srcOffsets[1].x),
RDCMIN(region.srcOffsets[0].y, region.srcOffsets[1].y),
RDCMIN(region.srcOffsets[0].z, region.srcOffsets[1].z)};
srcRange.extent = {
(uint32_t)(std::max(region.srcOffsets[0].x, region.srcOffsets[1].x) - srcRange.offset.x),
(uint32_t)(std::max(region.srcOffsets[0].y, region.srcOffsets[1].y) - srcRange.offset.y),
(uint32_t)(std::max(region.srcOffsets[0].z, region.srcOffsets[1].z) - srcRange.offset.z)};
(uint32_t)(RDCMAX(region.srcOffsets[0].x, region.srcOffsets[1].x) - srcRange.offset.x),
(uint32_t)(RDCMAX(region.srcOffsets[0].y, region.srcOffsets[1].y) - srcRange.offset.y),
(uint32_t)(RDCMAX(region.srcOffsets[0].z, region.srcOffsets[1].z) - srcRange.offset.z)};
ImageRange dstRange(region.dstSubresource);
dstRange.offset = {std::min(region.dstOffsets[0].x, region.dstOffsets[1].x),
std::min(region.dstOffsets[0].y, region.dstOffsets[1].y),
std::min(region.dstOffsets[0].z, region.dstOffsets[1].z)};
dstRange.offset = {RDCMIN(region.dstOffsets[0].x, region.dstOffsets[1].x),
RDCMIN(region.dstOffsets[0].y, region.dstOffsets[1].y),
RDCMIN(region.dstOffsets[0].z, region.dstOffsets[1].z)};
dstRange.extent = {
(uint32_t)(std::max(region.dstOffsets[0].x, region.dstOffsets[1].x) - dstRange.offset.x),
(uint32_t)(std::max(region.dstOffsets[0].y, region.dstOffsets[1].y) - dstRange.offset.y),
(uint32_t)(std::max(region.dstOffsets[0].z, region.dstOffsets[1].z) - dstRange.offset.z)};
(uint32_t)(RDCMAX(region.dstOffsets[0].x, region.dstOffsets[1].x) - dstRange.offset.x),
(uint32_t)(RDCMAX(region.dstOffsets[0].y, region.dstOffsets[1].y) - dstRange.offset.y),
(uint32_t)(RDCMAX(region.dstOffsets[0].z, region.dstOffsets[1].z) - dstRange.offset.z)};
record->MarkImageFrameReferenced(GetRecord(srcImage), srcRange, eFrameRef_Read);
record->MarkImageFrameReferenced(GetRecord(destImage), dstRange, eFrameRef_CompleteWrite);
@@ -3500,6 +3500,806 @@ void WrappedVulkan::vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer,
}
}
template <typename SerialiserType>
bool WrappedVulkan::Serialise_vkCmdCopyBuffer2KHR(SerialiserType &ser, VkCommandBuffer commandBuffer,
const VkCopyBufferInfo2KHR *pCopyBufferInfo)
{
SERIALISE_ELEMENT(commandBuffer);
SERIALISE_ELEMENT_LOCAL(CopyInfo, *pCopyBufferInfo);
Serialise_DebugMessages(ser);
SERIALISE_CHECK_READ_ERRORS();
if(IsReplayingAndReading())
{
VkCopyBufferInfo2KHR unwrappedInfo = CopyInfo;
unwrappedInfo.srcBuffer = Unwrap(unwrappedInfo.srcBuffer);
unwrappedInfo.dstBuffer = Unwrap(unwrappedInfo.dstBuffer);
byte *tempMem = GetTempMemory(GetNextPatchSize(unwrappedInfo.pNext));
UnwrapNextChain(m_State, "VkCopyBufferInfo2KHR", tempMem, (VkBaseInStructure *)&unwrappedInfo);
m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer));
if(IsActiveReplaying(m_State))
{
if(InRerecordRange(m_LastCmdBufferID))
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
uint32_t eventId = HandlePreCallback(commandBuffer, DrawFlags::Copy);
ObjDisp(commandBuffer)->CmdCopyBuffer2KHR(Unwrap(commandBuffer), &unwrappedInfo);
if(eventId && m_DrawcallCallback->PostMisc(eventId, DrawFlags::Copy, commandBuffer))
{
ObjDisp(commandBuffer)->CmdCopyBuffer2KHR(Unwrap(commandBuffer), &unwrappedInfo);
m_DrawcallCallback->PostRemisc(eventId, DrawFlags::Copy, commandBuffer);
}
}
}
else
{
ObjDisp(commandBuffer)->CmdCopyBuffer2KHR(Unwrap(commandBuffer), &unwrappedInfo);
{
AddEvent();
ResourceId srcid = GetResourceManager()->GetOriginalID(GetResID(CopyInfo.srcBuffer));
ResourceId dstid = GetResourceManager()->GetOriginalID(GetResID(CopyInfo.dstBuffer));
DrawcallDescription draw;
draw.name = StringFormat::Fmt("vkCmdCopyBuffer2KHR(%s, %s)", ToStr(srcid).c_str(),
ToStr(dstid).c_str());
draw.flags |= DrawFlags::Copy;
draw.copySource = srcid;
draw.copySourceSubresource = Subresource();
draw.copyDestination = dstid;
draw.copyDestinationSubresource = Subresource();
AddDrawcall(draw, true);
VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back();
if(srcid == dstid)
{
drawNode.resourceUsage.push_back(make_rdcpair(
GetResID(CopyInfo.srcBuffer), EventUsage(drawNode.draw.eventId, ResourceUsage::Copy)));
}
else
{
drawNode.resourceUsage.push_back(
make_rdcpair(GetResID(CopyInfo.srcBuffer),
EventUsage(drawNode.draw.eventId, ResourceUsage::CopySrc)));
drawNode.resourceUsage.push_back(
make_rdcpair(GetResID(CopyInfo.dstBuffer),
EventUsage(drawNode.draw.eventId, ResourceUsage::CopyDst)));
}
}
}
}
return true;
}
void WrappedVulkan::vkCmdCopyBuffer2KHR(VkCommandBuffer commandBuffer,
const VkCopyBufferInfo2KHR *pCopyBufferInfo)
{
SCOPED_DBG_SINK();
VkCopyBufferInfo2KHR unwrappedInfo = *pCopyBufferInfo;
unwrappedInfo.srcBuffer = Unwrap(unwrappedInfo.srcBuffer);
unwrappedInfo.dstBuffer = Unwrap(unwrappedInfo.dstBuffer);
byte *tempMem = GetTempMemory(GetNextPatchSize(unwrappedInfo.pNext));
UnwrapNextChain(m_State, "VkCopyBufferInfo2KHR", tempMem, (VkBaseInStructure *)&unwrappedInfo);
SERIALISE_TIME_CALL(
ObjDisp(commandBuffer)->CmdCopyBuffer2KHR(Unwrap(commandBuffer), &unwrappedInfo));
if(IsCaptureMode(m_State))
{
VkResourceRecord *record = GetRecord(commandBuffer);
CACHE_THREAD_SERIALISER();
ser.SetDrawChunk();
SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdCopyBuffer2KHR);
Serialise_vkCmdCopyBuffer2KHR(ser, commandBuffer, pCopyBufferInfo);
record->AddChunk(scope.Get(record->cmdInfo->alloc));
for(uint32_t i = 0; i < pCopyBufferInfo->regionCount; i++)
{
record->MarkBufferFrameReferenced(GetRecord(pCopyBufferInfo->srcBuffer),
pCopyBufferInfo->pRegions[i].srcOffset,
pCopyBufferInfo->pRegions[i].size, eFrameRef_Read);
record->MarkBufferFrameReferenced(GetRecord(pCopyBufferInfo->dstBuffer),
pCopyBufferInfo->pRegions[i].dstOffset,
pCopyBufferInfo->pRegions[i].size, eFrameRef_CompleteWrite);
}
}
}
template <typename SerialiserType>
bool WrappedVulkan::Serialise_vkCmdCopyImage2KHR(SerialiserType &ser, VkCommandBuffer commandBuffer,
const VkCopyImageInfo2KHR *pCopyImageInfo)
{
SERIALISE_ELEMENT(commandBuffer);
SERIALISE_ELEMENT_LOCAL(CopyInfo, *pCopyImageInfo);
Serialise_DebugMessages(ser);
SERIALISE_CHECK_READ_ERRORS();
if(IsReplayingAndReading())
{
VkCopyImageInfo2KHR unwrappedInfo = CopyInfo;
unwrappedInfo.srcImage = Unwrap(unwrappedInfo.srcImage);
unwrappedInfo.dstImage = Unwrap(unwrappedInfo.dstImage);
byte *tempMem = GetTempMemory(GetNextPatchSize(unwrappedInfo.pNext));
UnwrapNextChain(m_State, "VkCopyImageInfo2KHR", tempMem, (VkBaseInStructure *)&unwrappedInfo);
m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer));
if(IsActiveReplaying(m_State))
{
if(InRerecordRange(m_LastCmdBufferID))
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
uint32_t eventId = HandlePreCallback(commandBuffer, DrawFlags::Copy);
ObjDisp(commandBuffer)->CmdCopyImage2KHR(Unwrap(commandBuffer), &unwrappedInfo);
if(eventId && m_DrawcallCallback->PostMisc(eventId, DrawFlags::Copy, commandBuffer))
{
ObjDisp(commandBuffer)->CmdCopyImage2KHR(Unwrap(commandBuffer), &unwrappedInfo);
m_DrawcallCallback->PostRemisc(eventId, DrawFlags::Copy, commandBuffer);
}
}
}
else
{
ObjDisp(commandBuffer)->CmdCopyImage2KHR(Unwrap(commandBuffer), &unwrappedInfo);
{
AddEvent();
ResourceId srcid = GetResourceManager()->GetOriginalID(GetResID(CopyInfo.srcImage));
ResourceId dstid = GetResourceManager()->GetOriginalID(GetResID(CopyInfo.dstImage));
DrawcallDescription draw;
draw.name = StringFormat::Fmt("vkCmdCopyImage2KHR(%s, %s)", ToStr(srcid).c_str(),
ToStr(dstid).c_str());
draw.flags |= DrawFlags::Copy;
draw.copySource = srcid;
draw.copySourceSubresource = Subresource();
draw.copyDestination = dstid;
draw.copyDestinationSubresource = Subresource();
AddDrawcall(draw, true);
VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back();
if(srcid == dstid)
{
drawNode.resourceUsage.push_back(make_rdcpair(
GetResID(CopyInfo.srcImage), EventUsage(drawNode.draw.eventId, ResourceUsage::Copy)));
}
else
{
drawNode.resourceUsage.push_back(make_rdcpair(
GetResID(CopyInfo.srcImage), EventUsage(drawNode.draw.eventId, ResourceUsage::CopySrc)));
drawNode.resourceUsage.push_back(make_rdcpair(
GetResID(CopyInfo.dstImage), EventUsage(drawNode.draw.eventId, ResourceUsage::CopyDst)));
}
}
}
}
return true;
}
void WrappedVulkan::vkCmdCopyImage2KHR(VkCommandBuffer commandBuffer,
const VkCopyImageInfo2KHR *pCopyImageInfo)
{
SCOPED_DBG_SINK();
VkCopyImageInfo2KHR unwrappedInfo = *pCopyImageInfo;
unwrappedInfo.srcImage = Unwrap(unwrappedInfo.srcImage);
unwrappedInfo.dstImage = Unwrap(unwrappedInfo.dstImage);
byte *tempMem = GetTempMemory(GetNextPatchSize(unwrappedInfo.pNext));
UnwrapNextChain(m_State, "VkCopyImageInfo2KHR", tempMem, (VkBaseInStructure *)&unwrappedInfo);
SERIALISE_TIME_CALL(ObjDisp(commandBuffer)->CmdCopyImage2KHR(Unwrap(commandBuffer), &unwrappedInfo));
if(IsCaptureMode(m_State))
{
VkResourceRecord *record = GetRecord(commandBuffer);
CACHE_THREAD_SERIALISER();
ser.SetDrawChunk();
SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdCopyImage2KHR);
Serialise_vkCmdCopyImage2KHR(ser, commandBuffer, pCopyImageInfo);
record->AddChunk(scope.Get(record->cmdInfo->alloc));
for(uint32_t i = 0; i < pCopyImageInfo->regionCount; i++)
{
const VkImageCopy2KHR &region = pCopyImageInfo->pRegions[i];
ImageRange srcRange(region.srcSubresource);
srcRange.offset = region.srcOffset;
srcRange.extent = region.extent;
ImageRange dstRange(region.dstSubresource);
dstRange.offset = region.dstOffset;
dstRange.extent = region.extent;
record->MarkImageFrameReferenced(GetRecord(pCopyImageInfo->srcImage), srcRange, eFrameRef_Read);
record->MarkImageFrameReferenced(GetRecord(pCopyImageInfo->dstImage), dstRange,
eFrameRef_CompleteWrite);
}
}
}
template <typename SerialiserType>
bool WrappedVulkan::Serialise_vkCmdCopyBufferToImage2KHR(
SerialiserType &ser, VkCommandBuffer commandBuffer,
const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo)
{
SERIALISE_ELEMENT(commandBuffer);
SERIALISE_ELEMENT_LOCAL(CopyInfo, *pCopyBufferToImageInfo);
Serialise_DebugMessages(ser);
SERIALISE_CHECK_READ_ERRORS();
if(IsReplayingAndReading())
{
VkCopyBufferToImageInfo2KHR unwrappedInfo = CopyInfo;
unwrappedInfo.srcBuffer = Unwrap(unwrappedInfo.srcBuffer);
unwrappedInfo.dstImage = Unwrap(unwrappedInfo.dstImage);
byte *tempMem = GetTempMemory(GetNextPatchSize(unwrappedInfo.pNext));
UnwrapNextChain(m_State, "VkCopyBufferToImageInfo2KHR", tempMem,
(VkBaseInStructure *)&unwrappedInfo);
m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer));
if(IsActiveReplaying(m_State))
{
if(InRerecordRange(m_LastCmdBufferID))
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
uint32_t eventId = HandlePreCallback(commandBuffer, DrawFlags::Copy);
ObjDisp(commandBuffer)->CmdCopyBufferToImage2KHR(Unwrap(commandBuffer), &unwrappedInfo);
if(eventId && m_DrawcallCallback->PostMisc(eventId, DrawFlags::Copy, commandBuffer))
{
ObjDisp(commandBuffer)->CmdCopyBufferToImage2KHR(Unwrap(commandBuffer), &unwrappedInfo);
m_DrawcallCallback->PostRemisc(eventId, DrawFlags::Copy, commandBuffer);
}
}
}
else
{
ObjDisp(commandBuffer)->CmdCopyBufferToImage2KHR(Unwrap(commandBuffer), &unwrappedInfo);
{
AddEvent();
ResourceId bufid = GetResourceManager()->GetOriginalID(GetResID(CopyInfo.srcBuffer));
ResourceId imgid = GetResourceManager()->GetOriginalID(GetResID(CopyInfo.dstImage));
DrawcallDescription draw;
draw.name = StringFormat::Fmt("vkCmdCopyBufferToImage2KHR(%s, %s)", ToStr(bufid).c_str(),
ToStr(imgid).c_str());
draw.flags |= DrawFlags::Copy;
draw.copySource = bufid;
draw.copySourceSubresource = Subresource();
draw.copyDestination = imgid;
draw.copyDestinationSubresource = Subresource();
if(CopyInfo.regionCount > 0)
draw.copyDestinationSubresource =
Subresource(CopyInfo.pRegions[0].imageSubresource.mipLevel,
CopyInfo.pRegions[0].imageSubresource.baseArrayLayer);
AddDrawcall(draw, true);
VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back();
drawNode.resourceUsage.push_back(make_rdcpair(
GetResID(CopyInfo.srcBuffer), EventUsage(drawNode.draw.eventId, ResourceUsage::CopySrc)));
drawNode.resourceUsage.push_back(make_rdcpair(
GetResID(CopyInfo.dstImage), EventUsage(drawNode.draw.eventId, ResourceUsage::CopyDst)));
}
}
}
return true;
}
void WrappedVulkan::vkCmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer,
const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo)
{
SCOPED_DBG_SINK();
VkCopyBufferToImageInfo2KHR unwrappedInfo = *pCopyBufferToImageInfo;
unwrappedInfo.srcBuffer = Unwrap(unwrappedInfo.srcBuffer);
unwrappedInfo.dstImage = Unwrap(unwrappedInfo.dstImage);
byte *tempMem = GetTempMemory(GetNextPatchSize(unwrappedInfo.pNext));
UnwrapNextChain(m_State, "VkCopyBufferToImageInfo2KHR", tempMem,
(VkBaseInStructure *)&unwrappedInfo);
SERIALISE_TIME_CALL(
ObjDisp(commandBuffer)->CmdCopyBufferToImage2KHR(Unwrap(commandBuffer), &unwrappedInfo));
if(IsCaptureMode(m_State))
{
VkResourceRecord *record = GetRecord(commandBuffer);
CACHE_THREAD_SERIALISER();
ser.SetDrawChunk();
SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdCopyBufferToImage2KHR);
Serialise_vkCmdCopyBufferToImage2KHR(ser, commandBuffer, pCopyBufferToImageInfo);
record->AddChunk(scope.Get(record->cmdInfo->alloc));
// downcast the VkBufferImageCopy2KHR to VkBufferImageCopy for ease of use, as we don't need
// anything in the next chains here
// we're done with temp memory above so we can reuse here
VkBufferImageCopy *pRegions =
GetTempArray<VkBufferImageCopy>(pCopyBufferToImageInfo->regionCount);
for(uint32_t i = 0; i < pCopyBufferToImageInfo->regionCount; i++)
{
pRegions[i].bufferOffset = pCopyBufferToImageInfo->pRegions[i].bufferOffset;
pRegions[i].bufferRowLength = pCopyBufferToImageInfo->pRegions[i].bufferRowLength;
pRegions[i].bufferImageHeight = pCopyBufferToImageInfo->pRegions[i].bufferImageHeight;
pRegions[i].imageSubresource = pCopyBufferToImageInfo->pRegions[i].imageSubresource;
pRegions[i].imageOffset = pCopyBufferToImageInfo->pRegions[i].imageOffset;
pRegions[i].imageExtent = pCopyBufferToImageInfo->pRegions[i].imageExtent;
}
record->MarkBufferImageCopyFrameReferenced(
GetRecord(pCopyBufferToImageInfo->srcBuffer), GetRecord(pCopyBufferToImageInfo->dstImage),
pCopyBufferToImageInfo->regionCount, pRegions, eFrameRef_Read, eFrameRef_CompleteWrite);
}
}
template <typename SerialiserType>
bool WrappedVulkan::Serialise_vkCmdCopyImageToBuffer2KHR(
SerialiserType &ser, VkCommandBuffer commandBuffer,
const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo)
{
SERIALISE_ELEMENT(commandBuffer);
SERIALISE_ELEMENT_LOCAL(CopyInfo, *pCopyImageToBufferInfo);
Serialise_DebugMessages(ser);
SERIALISE_CHECK_READ_ERRORS();
if(IsReplayingAndReading())
{
VkCopyImageToBufferInfo2KHR unwrappedInfo = CopyInfo;
unwrappedInfo.srcImage = Unwrap(unwrappedInfo.srcImage);
unwrappedInfo.dstBuffer = Unwrap(unwrappedInfo.dstBuffer);
byte *tempMem = GetTempMemory(GetNextPatchSize(unwrappedInfo.pNext));
UnwrapNextChain(m_State, "VkCopyImageToBufferInfo2KHR", tempMem,
(VkBaseInStructure *)&unwrappedInfo);
m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer));
if(IsActiveReplaying(m_State))
{
if(InRerecordRange(m_LastCmdBufferID))
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
uint32_t eventId = HandlePreCallback(commandBuffer, DrawFlags::Copy);
ObjDisp(commandBuffer)->CmdCopyImageToBuffer2KHR(Unwrap(commandBuffer), &unwrappedInfo);
if(eventId && m_DrawcallCallback->PostMisc(eventId, DrawFlags::Copy, commandBuffer))
{
ObjDisp(commandBuffer)->CmdCopyImageToBuffer2KHR(Unwrap(commandBuffer), &unwrappedInfo);
m_DrawcallCallback->PostRemisc(eventId, DrawFlags::Copy, commandBuffer);
}
}
}
else
{
ObjDisp(commandBuffer)->CmdCopyImageToBuffer2KHR(Unwrap(commandBuffer), &unwrappedInfo);
{
AddEvent();
ResourceId imgid = GetResourceManager()->GetOriginalID(GetResID(CopyInfo.srcImage));
ResourceId bufid = GetResourceManager()->GetOriginalID(GetResID(CopyInfo.dstBuffer));
DrawcallDescription draw;
draw.name = StringFormat::Fmt("vkCmdCopyImageToBuffer2KHR(%s, %s)", ToStr(imgid).c_str(),
ToStr(bufid).c_str());
draw.flags |= DrawFlags::Copy;
draw.copySource = imgid;
draw.copySourceSubresource = Subresource();
if(CopyInfo.regionCount > 0)
draw.copySourceSubresource =
Subresource(CopyInfo.pRegions[0].imageSubresource.mipLevel,
CopyInfo.pRegions[0].imageSubresource.baseArrayLayer);
draw.copyDestination = bufid;
draw.copyDestinationSubresource = Subresource();
AddDrawcall(draw, true);
VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back();
drawNode.resourceUsage.push_back(make_rdcpair(
GetResID(CopyInfo.srcImage), EventUsage(drawNode.draw.eventId, ResourceUsage::CopySrc)));
drawNode.resourceUsage.push_back(make_rdcpair(
GetResID(CopyInfo.dstBuffer), EventUsage(drawNode.draw.eventId, ResourceUsage::CopyDst)));
}
}
}
return true;
}
void WrappedVulkan::vkCmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer,
const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo)
{
SCOPED_DBG_SINK();
VkCopyImageToBufferInfo2KHR unwrappedInfo = *pCopyImageToBufferInfo;
unwrappedInfo.srcImage = Unwrap(unwrappedInfo.srcImage);
unwrappedInfo.dstBuffer = Unwrap(unwrappedInfo.dstBuffer);
byte *tempMem = GetTempMemory(GetNextPatchSize(unwrappedInfo.pNext));
UnwrapNextChain(m_State, "VkCopyImageToBufferInfo2KHR", tempMem,
(VkBaseInStructure *)&unwrappedInfo);
SERIALISE_TIME_CALL(
ObjDisp(commandBuffer)->CmdCopyImageToBuffer2KHR(Unwrap(commandBuffer), &unwrappedInfo));
if(IsCaptureMode(m_State))
{
VkResourceRecord *record = GetRecord(commandBuffer);
CACHE_THREAD_SERIALISER();
ser.SetDrawChunk();
SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdCopyImageToBuffer2KHR);
Serialise_vkCmdCopyImageToBuffer2KHR(ser, commandBuffer, pCopyImageToBufferInfo);
record->AddChunk(scope.Get(record->cmdInfo->alloc));
// downcast the VkBufferImageCopy2KHR to VkBufferImageCopy for ease of use, as we don't need
// anything in the next chains here
// we're done with temp memory above so we can reuse here
VkBufferImageCopy *pRegions =
GetTempArray<VkBufferImageCopy>(pCopyImageToBufferInfo->regionCount);
for(uint32_t i = 0; i < pCopyImageToBufferInfo->regionCount; i++)
{
pRegions[i].bufferOffset = pCopyImageToBufferInfo->pRegions[i].bufferOffset;
pRegions[i].bufferRowLength = pCopyImageToBufferInfo->pRegions[i].bufferRowLength;
pRegions[i].bufferImageHeight = pCopyImageToBufferInfo->pRegions[i].bufferImageHeight;
pRegions[i].imageSubresource = pCopyImageToBufferInfo->pRegions[i].imageSubresource;
pRegions[i].imageOffset = pCopyImageToBufferInfo->pRegions[i].imageOffset;
pRegions[i].imageExtent = pCopyImageToBufferInfo->pRegions[i].imageExtent;
}
record->MarkBufferImageCopyFrameReferenced(
GetRecord(pCopyImageToBufferInfo->dstBuffer), GetRecord(pCopyImageToBufferInfo->srcImage),
pCopyImageToBufferInfo->regionCount, pRegions, eFrameRef_CompleteWrite, eFrameRef_Read);
}
}
template <typename SerialiserType>
bool WrappedVulkan::Serialise_vkCmdBlitImage2KHR(SerialiserType &ser, VkCommandBuffer commandBuffer,
const VkBlitImageInfo2KHR *pBlitImageInfo)
{
SERIALISE_ELEMENT(commandBuffer);
SERIALISE_ELEMENT_LOCAL(BlitInfo, *pBlitImageInfo);
Serialise_DebugMessages(ser);
SERIALISE_CHECK_READ_ERRORS();
if(IsReplayingAndReading())
{
VkBlitImageInfo2KHR unwrappedInfo = BlitInfo;
unwrappedInfo.srcImage = Unwrap(unwrappedInfo.srcImage);
unwrappedInfo.dstImage = Unwrap(unwrappedInfo.dstImage);
byte *tempMem = GetTempMemory(GetNextPatchSize(unwrappedInfo.pNext));
UnwrapNextChain(m_State, "VkBlitImageInfo2KHR", tempMem, (VkBaseInStructure *)&unwrappedInfo);
m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer));
if(IsActiveReplaying(m_State))
{
if(InRerecordRange(m_LastCmdBufferID))
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
uint32_t eventId = HandlePreCallback(commandBuffer, DrawFlags::Resolve);
ObjDisp(commandBuffer)->CmdBlitImage2KHR(Unwrap(commandBuffer), &unwrappedInfo);
if(eventId && m_DrawcallCallback->PostMisc(eventId, DrawFlags::Resolve, commandBuffer))
{
ObjDisp(commandBuffer)->CmdBlitImage2KHR(Unwrap(commandBuffer), &unwrappedInfo);
m_DrawcallCallback->PostRemisc(eventId, DrawFlags::Resolve, commandBuffer);
}
}
}
else
{
ObjDisp(commandBuffer)->CmdBlitImage2KHR(Unwrap(commandBuffer), &unwrappedInfo);
{
AddEvent();
ResourceId srcid = GetResourceManager()->GetOriginalID(GetResID(BlitInfo.srcImage));
ResourceId dstid = GetResourceManager()->GetOriginalID(GetResID(BlitInfo.dstImage));
DrawcallDescription draw;
draw.name = StringFormat::Fmt("vkCmdBlitImage2KHR(%s, %s)", ToStr(srcid).c_str(),
ToStr(dstid).c_str());
draw.flags |= DrawFlags::Resolve;
draw.copySource = srcid;
draw.copySourceSubresource = Subresource();
draw.copyDestination = dstid;
draw.copyDestinationSubresource = Subresource();
AddDrawcall(draw, true);
VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back();
if(srcid == dstid)
{
drawNode.resourceUsage.push_back(make_rdcpair(
GetResID(BlitInfo.srcImage), EventUsage(drawNode.draw.eventId, ResourceUsage::Resolve)));
}
else
{
drawNode.resourceUsage.push_back(
make_rdcpair(GetResID(BlitInfo.srcImage),
EventUsage(drawNode.draw.eventId, ResourceUsage::ResolveSrc)));
drawNode.resourceUsage.push_back(
make_rdcpair(GetResID(BlitInfo.dstImage),
EventUsage(drawNode.draw.eventId, ResourceUsage::ResolveDst)));
}
}
}
}
return true;
}
void WrappedVulkan::vkCmdBlitImage2KHR(VkCommandBuffer commandBuffer,
const VkBlitImageInfo2KHR *pBlitImageInfo)
{
SCOPED_DBG_SINK();
VkBlitImageInfo2KHR unwrappedInfo = *pBlitImageInfo;
unwrappedInfo.srcImage = Unwrap(unwrappedInfo.srcImage);
unwrappedInfo.dstImage = Unwrap(unwrappedInfo.dstImage);
byte *tempMem = GetTempMemory(GetNextPatchSize(unwrappedInfo.pNext));
UnwrapNextChain(m_State, "VkBlitImageInfo2KHR", tempMem, (VkBaseInStructure *)&unwrappedInfo);
SERIALISE_TIME_CALL(ObjDisp(commandBuffer)->CmdBlitImage2KHR(Unwrap(commandBuffer), &unwrappedInfo));
if(IsCaptureMode(m_State))
{
VkResourceRecord *record = GetRecord(commandBuffer);
CACHE_THREAD_SERIALISER();
ser.SetDrawChunk();
SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdBlitImage2KHR);
Serialise_vkCmdBlitImage2KHR(ser, commandBuffer, pBlitImageInfo);
record->AddChunk(scope.Get(record->cmdInfo->alloc));
for(uint32_t i = 0; i < pBlitImageInfo->regionCount; i++)
{
const VkImageBlit2KHR &region = pBlitImageInfo->pRegions[i];
ImageRange srcRange(region.srcSubresource);
srcRange.offset = {RDCMIN(region.srcOffsets[0].x, region.srcOffsets[1].x),
RDCMIN(region.srcOffsets[0].y, region.srcOffsets[1].y),
RDCMIN(region.srcOffsets[0].z, region.srcOffsets[1].z)};
srcRange.extent = {
(uint32_t)(RDCMAX(region.srcOffsets[0].x, region.srcOffsets[1].x) - srcRange.offset.x),
(uint32_t)(RDCMAX(region.srcOffsets[0].y, region.srcOffsets[1].y) - srcRange.offset.y),
(uint32_t)(RDCMAX(region.srcOffsets[0].z, region.srcOffsets[1].z) - srcRange.offset.z)};
ImageRange dstRange(region.dstSubresource);
dstRange.offset = {RDCMIN(region.dstOffsets[0].x, region.dstOffsets[1].x),
RDCMIN(region.dstOffsets[0].y, region.dstOffsets[1].y),
RDCMIN(region.dstOffsets[0].z, region.dstOffsets[1].z)};
dstRange.extent = {
(uint32_t)(RDCMAX(region.dstOffsets[0].x, region.dstOffsets[1].x) - dstRange.offset.x),
(uint32_t)(RDCMAX(region.dstOffsets[0].y, region.dstOffsets[1].y) - dstRange.offset.y),
(uint32_t)(RDCMAX(region.dstOffsets[0].z, region.dstOffsets[1].z) - dstRange.offset.z)};
record->MarkImageFrameReferenced(GetRecord(pBlitImageInfo->srcImage), srcRange, eFrameRef_Read);
record->MarkImageFrameReferenced(GetRecord(pBlitImageInfo->dstImage), dstRange,
eFrameRef_CompleteWrite);
}
}
}
template <typename SerialiserType>
bool WrappedVulkan::Serialise_vkCmdResolveImage2KHR(SerialiserType &ser,
VkCommandBuffer commandBuffer,
const VkResolveImageInfo2KHR *pResolveImageInfo)
{
SERIALISE_ELEMENT(commandBuffer);
SERIALISE_ELEMENT_LOCAL(ResolveInfo, *pResolveImageInfo);
Serialise_DebugMessages(ser);
SERIALISE_CHECK_READ_ERRORS();
if(IsReplayingAndReading())
{
VkResolveImageInfo2KHR unwrappedInfo = ResolveInfo;
unwrappedInfo.srcImage = Unwrap(unwrappedInfo.srcImage);
unwrappedInfo.dstImage = Unwrap(unwrappedInfo.dstImage);
byte *tempMem = GetTempMemory(GetNextPatchSize(unwrappedInfo.pNext));
UnwrapNextChain(m_State, "VkResolveImageInfo2KHR", tempMem, (VkBaseInStructure *)&unwrappedInfo);
m_LastCmdBufferID = GetResourceManager()->GetOriginalID(GetResID(commandBuffer));
if(IsActiveReplaying(m_State))
{
if(InRerecordRange(m_LastCmdBufferID))
{
commandBuffer = RerecordCmdBuf(m_LastCmdBufferID);
uint32_t eventId = HandlePreCallback(commandBuffer, DrawFlags::Resolve);
ObjDisp(commandBuffer)->CmdResolveImage2KHR(Unwrap(commandBuffer), &unwrappedInfo);
if(eventId && m_DrawcallCallback->PostMisc(eventId, DrawFlags::Resolve, commandBuffer))
{
ObjDisp(commandBuffer)->CmdResolveImage2KHR(Unwrap(commandBuffer), &unwrappedInfo);
m_DrawcallCallback->PostRemisc(eventId, DrawFlags::Resolve, commandBuffer);
}
}
}
else
{
ObjDisp(commandBuffer)->CmdResolveImage2KHR(Unwrap(commandBuffer), &unwrappedInfo);
{
AddEvent();
ResourceId srcid = GetResourceManager()->GetOriginalID(GetResID(ResolveInfo.srcImage));
ResourceId dstid = GetResourceManager()->GetOriginalID(GetResID(ResolveInfo.dstImage));
DrawcallDescription draw;
draw.name = StringFormat::Fmt("vkCmdResolveImage2KHR(%s, %s)", ToStr(srcid).c_str(),
ToStr(dstid).c_str());
draw.flags |= DrawFlags::Resolve;
draw.copySource = srcid;
draw.copySourceSubresource = Subresource();
draw.copyDestination = dstid;
draw.copyDestinationSubresource = Subresource();
AddDrawcall(draw, true);
VulkanDrawcallTreeNode &drawNode = GetDrawcallStack().back()->children.back();
if(srcid == dstid)
{
drawNode.resourceUsage.push_back(
make_rdcpair(GetResID(ResolveInfo.srcImage),
EventUsage(drawNode.draw.eventId, ResourceUsage::Resolve)));
}
else
{
drawNode.resourceUsage.push_back(
make_rdcpair(GetResID(ResolveInfo.srcImage),
EventUsage(drawNode.draw.eventId, ResourceUsage::ResolveSrc)));
drawNode.resourceUsage.push_back(
make_rdcpair(GetResID(ResolveInfo.dstImage),
EventUsage(drawNode.draw.eventId, ResourceUsage::ResolveDst)));
}
}
}
}
return true;
}
void WrappedVulkan::vkCmdResolveImage2KHR(VkCommandBuffer commandBuffer,
const VkResolveImageInfo2KHR *pResolveImageInfo)
{
SCOPED_DBG_SINK();
VkResolveImageInfo2KHR unwrappedInfo = *pResolveImageInfo;
unwrappedInfo.srcImage = Unwrap(unwrappedInfo.srcImage);
unwrappedInfo.dstImage = Unwrap(unwrappedInfo.dstImage);
byte *tempMem = GetTempMemory(GetNextPatchSize(unwrappedInfo.pNext));
UnwrapNextChain(m_State, "VkResolveImageInfo2KHR", tempMem, (VkBaseInStructure *)&unwrappedInfo);
SERIALISE_TIME_CALL(
ObjDisp(commandBuffer)->CmdResolveImage2KHR(Unwrap(commandBuffer), &unwrappedInfo));
if(IsCaptureMode(m_State))
{
VkResourceRecord *record = GetRecord(commandBuffer);
CACHE_THREAD_SERIALISER();
ser.SetDrawChunk();
SCOPED_SERIALISE_CHUNK(VulkanChunk::vkCmdResolveImage2KHR);
Serialise_vkCmdResolveImage2KHR(ser, commandBuffer, pResolveImageInfo);
record->AddChunk(scope.Get(record->cmdInfo->alloc));
for(uint32_t i = 0; i < pResolveImageInfo->regionCount; i++)
{
const VkImageResolve2KHR &region = pResolveImageInfo->pRegions[i];
ImageRange srcRange(region.srcSubresource);
srcRange.offset = region.srcOffset;
srcRange.extent = region.extent;
ImageRange dstRange(region.dstSubresource);
dstRange.offset = region.dstOffset;
dstRange.extent = region.extent;
record->MarkImageFrameReferenced(GetRecord(pResolveImageInfo->srcImage), srcRange,
eFrameRef_Read);
record->MarkImageFrameReferenced(GetRecord(pResolveImageInfo->dstImage), dstRange,
eFrameRef_CompleteWrite);
}
}
}
INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdDraw, VkCommandBuffer commandBuffer, uint32_t vertexCount,
uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
@@ -3584,3 +4384,15 @@ INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdDrawIndirectByteCountEXT, VkCommandBu
uint32_t instanceCount, uint32_t firstInstance,
VkBuffer counterBuffer, VkDeviceSize counterBufferOffset,
uint32_t counterOffset, uint32_t vertexStride);
INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdCopyBuffer2KHR, VkCommandBuffer commandBuffer,
const VkCopyBufferInfo2KHR *pCopyBufferInfo);
INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdCopyImage2KHR, VkCommandBuffer commandBuffer,
const VkCopyImageInfo2KHR *pCopyImageInfo);
INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdCopyBufferToImage2KHR, VkCommandBuffer commandBuffer,
const VkCopyBufferToImageInfo2KHR *pCopyBufferToImageInfo);
INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdCopyImageToBuffer2KHR, VkCommandBuffer commandBuffer,
const VkCopyImageToBufferInfo2KHR *pCopyImageToBufferInfo);
INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdBlitImage2KHR, VkCommandBuffer commandBuffer,
const VkBlitImageInfo2KHR *pBlitImageInfo);
INSTANTIATE_FUNCTION_SERIALISED(void, vkCmdResolveImage2KHR, VkCommandBuffer commandBuffer,
const VkResolveImageInfo2KHR *pResolveImageInfo);