From 965535560b19efa68eb63170fe68523bcb539b71 Mon Sep 17 00:00:00 2001 From: baldurk Date: Tue, 20 Oct 2020 12:40:43 +0100 Subject: [PATCH] Implement support for VK_KHR_copy_commands2 --- renderdoc/driver/vulkan/vk_common.h | 28 + renderdoc/driver/vulkan/vk_core.cpp | 16 + renderdoc/driver/vulkan/vk_core.h | 14 + renderdoc/driver/vulkan/vk_hookset_defs.h | 24 +- renderdoc/driver/vulkan/vk_next_chains.cpp | 356 +++++++- renderdoc/driver/vulkan/vk_serialise.cpp | 253 +++++- renderdoc/driver/vulkan/vk_stringise.cpp | 8 +- .../driver/vulkan/wrappers/vk_draw_funcs.cpp | 836 +++++++++++++++++- 8 files changed, 1475 insertions(+), 60 deletions(-) diff --git a/renderdoc/driver/vulkan/vk_common.h b/renderdoc/driver/vulkan/vk_common.h index 367d5ea95..cfedf3537 100644 --- a/renderdoc/driver/vulkan/vk_common.h +++ b/renderdoc/driver/vulkan/vk_common.h @@ -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); diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index 7e35a73c6..a2dafd7ca 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -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: diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index 3c2fabc2f..fa51db821 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -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); }; diff --git a/renderdoc/driver/vulkan/vk_hookset_defs.h b/renderdoc/driver/vulkan/vk_hookset_defs.h index c22f97dc0..abbfbbb8b 100644 --- a/renderdoc/driver/vulkan/vk_hookset_defs.h +++ b/renderdoc/driver/vulkan/vk_hookset_defs.h @@ -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(); \ diff --git a/renderdoc/driver/vulkan/vk_next_chains.cpp b/renderdoc/driver/vulkan/vk_next_chains.cpp index 77261a0d1..89ae86419 100644 --- a/renderdoc/driver/vulkan/vk_next_chains.cpp +++ b/renderdoc/driver/vulkan/vk_next_chains.cpp @@ -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 +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 @@ -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; diff --git a/renderdoc/driver/vulkan/vk_serialise.cpp b/renderdoc/driver/vulkan/vk_serialise.cpp index 72a5849ad..3208b1b7a 100644 --- a/renderdoc/driver/vulkan/vk_serialise.cpp +++ b/renderdoc/driver/vulkan/vk_serialise.cpp @@ -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 +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 +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 +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 +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 +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 +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 +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 +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 +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 +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 +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 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); diff --git a/renderdoc/driver/vulkan/vk_stringise.cpp b/renderdoc/driver/vulkan/vk_stringise.cpp index 5b58853fb..a74567789 100644 --- a/renderdoc/driver/vulkan/vk_stringise.cpp +++ b/renderdoc/driver/vulkan/vk_stringise.cpp @@ -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() diff --git a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp index 595d0762e..c5cc8e60a 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_draw_funcs.cpp @@ -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 +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 +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 ®ion = 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 +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(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 +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(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 +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 ®ion = 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 +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 ®ion = 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);