lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-08-05 14:21:10 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
36b9980de1921ad1ae7c30ca84e16dbcc9db1ef5
renderdoc/renderdoc/driver/vulkan/vk_next_chains.cpp
T

2578 lines
151 KiB
C++
Raw Blame History

/******************************************************************************
* The MIT License (MIT)
*
* Copyright (c) 2019-2021 Baldur Karlsson
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
******************************************************************************/
#include "vk_common.h"
#include "vk_resources.h"
template <typename VkStruct>
static void UnwrapInPlace(VkStruct &s)
{
s = Unwrap(s);
}
// utility function for when we're modifying one struct in a pNext chain, this
// lets us just copy across a struct unmodified into some temporary memory and
// append it onto a pNext chain we're building
static void CopyNextChainedStruct(const size_t structSize, byte *&tempMem,
const VkBaseInStructure *nextInput,
VkBaseInStructure *&nextChainTail)
{
VkBaseInStructure *outstruct = (VkBaseInStructure *)tempMem;
tempMem += structSize;
// copy the struct, nothing to unwrap
memcpy(outstruct, nextInput, structSize);
// default to NULL. It will be overwritten next time if there is a next object
outstruct->pNext = NULL;
// append this onto the chain
nextChainTail->pNext = outstruct;
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>
static void AppendModifiedChainedStruct(byte *&tempMem, VkStruct *outputStruct,
VkBaseInStructure *&nextChainTail)
{
tempMem = (byte *)(outputStruct + 1);
// default to NULL. It will be overwritten in the next step if there is a next object
outputStruct->pNext = NULL;
// append this onto the chain
nextChainTail->pNext = (const VkBaseInStructure *)outputStruct;
nextChainTail = (VkBaseInStructure *)outputStruct;
}
// define structs that just need to be copied with no unwrapping at all, or only unwrapping some
// members - easily shared between GetNextPatchSize and UnwrapNextChain
#define PROCESS_SIMPLE_STRUCTS() \
COPY_STRUCT(VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR, VkAcquireProfilingLockInfoKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_APPLICATION_INFO, VkApplicationInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, VkAttachmentDescription2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, \
VkAttachmentDescriptionStencilLayout); \
COPY_STRUCT(VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, VkAttachmentReference2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, \
VkAttachmentReferenceStencilLayout); \
COPY_STRUCT(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, \
VkBindBufferMemoryDeviceGroupInfo); \
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); \
COPY_STRUCT(VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, VkCommandBufferBeginInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT, \
VkCommandBufferInheritanceConditionalRenderingInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, VkCommandPoolCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT, VkDebugMarkerMarkerInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, \
VkDebugReportCallbackCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT, VkDebugUtilsLabelEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT, \
VkDebugUtilsMessengerCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV, \
VkDedicatedAllocationBufferCreateInfoNV); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV, \
VkDedicatedAllocationImageCreateInfoNV); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, VkDescriptorPoolCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT, \
VkDescriptorPoolInlineUniformBlockCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, \
VkDescriptorSetLayoutBindingFlagsCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, VkDescriptorSetLayoutSupport); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, \
VkDescriptorSetVariableDescriptorCountAllocateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, \
VkDescriptorSetVariableDescriptorCountLayoutSupport); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, VkDeviceCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, VkDeviceGroupBindSparseInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, \
VkDeviceGroupCommandBufferBeginInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR, \
VkDeviceGroupPresentCapabilitiesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR, VkDeviceGroupPresentInfoKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, \
VkDeviceGroupRenderPassBeginInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, VkDeviceGroupSubmitInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR, \
VkDeviceGroupSwapchainCreateInfoKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT, \
VkDevicePrivateDataCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, VkDeviceQueueCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT, \
VkDeviceQueueGlobalPriorityCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2, VkDeviceQueueInfo2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR, VkDisplayModeProperties2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD, \
VkDisplayNativeHdrSurfaceCapabilitiesAMD) \
COPY_STRUCT(VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR, VkDisplayPlaneCapabilities2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR, VkDisplayPlaneInfo2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR, VkDisplayPlaneProperties2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR, VkDisplayPresentInfoKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR, VkDisplayProperties2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_EVENT_CREATE_INFO, VkEventCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, VkExternalBufferProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, VkExternalImageFormatProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, VkFenceCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT, \
VkFilterCubicImageViewImageFormatPropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, VkFormatProperties2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR, VkFormatProperties3KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_HDR_METADATA_EXT, VkHdrMetadataEXT) \
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); \
COPY_STRUCT(VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, VkInstanceCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, VkMemoryAllocateFlagsInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, VkMemoryAllocateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_BARRIER, VkMemoryBarrier); \
COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR, VkMemoryBarrier2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, VkMemoryDedicatedRequirements); \
COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, \
VkMemoryOpaqueCaptureAddressAllocateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT, VkMemoryPriorityAllocateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, VkMemoryRequirements2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, VkMultisamplePropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR, \
VkPerformanceCounterDescriptionKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR, VkPerformanceCounterKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR, VkPerformanceQuerySubmitInfoKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, \
VkPhysicalDevice16BitStorageFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, \
VkPhysicalDevice8BitStorageFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, \
VkPhysicalDeviceASTCDecodeFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, \
VkPhysicalDeviceBufferDeviceAddressFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, \
VkPhysicalDeviceBufferDeviceAddressFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, \
VkPhysicalDeviceCoherentMemoryFeaturesAMD); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, \
VkPhysicalDeviceComputeShaderDerivativesFeaturesNV); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, \
VkPhysicalDeviceConditionalRenderingFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT, \
VkPhysicalDeviceConservativeRasterizationPropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT, \
VkPhysicalDeviceCustomBorderColorFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT, \
VkPhysicalDeviceCustomBorderColorPropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, \
VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, \
VkPhysicalDeviceDepthClipEnableFeaturesEXT) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, \
VkPhysicalDeviceDepthStencilResolveProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, \
VkPhysicalDeviceDescriptorIndexingFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, \
VkPhysicalDeviceDescriptorIndexingProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT, \
VkPhysicalDeviceDiscardRectanglePropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, \
VkPhysicalDeviceDriverProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT, \
VkPhysicalDeviceExtendedDynamicStateFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, \
VkPhysicalDeviceExternalBufferInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, \
VkPhysicalDeviceExternalImageFormatInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, \
VkPhysicalDeviceExternalSemaphoreInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, VkPhysicalDeviceFeatures2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, \
VkPhysicalDeviceFloatControlsProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, \
VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, VkPhysicalDeviceGroupProperties) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, \
VkPhysicalDeviceShaderFloat16Int8Features); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, \
VkPhysicalDeviceFragmentDensityMapFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT, \
VkPhysicalDeviceFragmentDensityMapPropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT, \
VkPhysicalDeviceFragmentDensityMap2FeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT, \
VkPhysicalDeviceFragmentDensityMap2PropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, \
VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, \
VkPhysicalDeviceHostQueryResetFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, VkPhysicalDeviceIDProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, \
VkPhysicalDeviceImageFormatInfo2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT, \
VkPhysicalDeviceImageViewImageFormatInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, \
VkPhysicalDeviceImagelessFramebufferFeatures) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT, \
VkPhysicalDeviceImageRobustnessFeaturesEXT) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, \
VkPhysicalDeviceIndexTypeUint8FeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, \
VkPhysicalDeviceInlineUniformBlockFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT, \
VkPhysicalDeviceInlineUniformBlockPropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, \
VkPhysicalDeviceMaintenance3Properties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR, \
VkPhysicalDeviceMaintenance4FeaturesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR, \
VkPhysicalDeviceMaintenance4PropertiesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT, \
VkPhysicalDeviceMemoryBudgetPropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, \
VkPhysicalDeviceMemoryProperties2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, \
VkPhysicalDeviceMemoryPriorityFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, \
VkPhysicalDeviceMultiviewFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, \
VkPhysicalDeviceMultiviewProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, \
VkPhysicalDeviceLineRasterizationFeaturesEXT) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT, \
VkPhysicalDeviceLineRasterizationPropertiesEXT) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT, \
VkPhysicalDevicePCIBusInfoPropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, \
VkPhysicalDevicePerformanceQueryFeaturesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR, \
VkPhysicalDevicePerformanceQueryPropertiesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT, \
VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, \
VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, \
VkPhysicalDevicePointClippingProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT, \
VkPhysicalDevicePrivateDataFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR, \
VkPhysicalDevicePresentIdFeaturesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR, \
VkPhysicalDevicePresentWaitFeaturesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, VkPhysicalDeviceProperties2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, \
VkPhysicalDeviceProtectedMemoryFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES, \
VkPhysicalDeviceProtectedMemoryProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR, \
VkPhysicalDevicePushDescriptorPropertiesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT, \
VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT, \
VkPhysicalDeviceRobustness2FeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT, \
VkPhysicalDeviceRobustness2PropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT, \
VkPhysicalDeviceSampleLocationsPropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, \
VkPhysicalDeviceSamplerFilterMinmaxProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, \
VkPhysicalDeviceSamplerYcbcrConversionFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, \
VkPhysicalDeviceScalarBlockLayoutFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, \
VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, \
VkPhysicalDeviceShaderAtomicInt64Features); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT, \
VkPhysicalDeviceShaderAtomicFloatFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT, \
VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD, \
VkPhysicalDeviceShaderCorePropertiesAMD); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, \
VkPhysicalDeviceShaderClockFeaturesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, \
VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, \
VkPhysicalDeviceShaderDrawParametersFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT, \
VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, \
VkPhysicalDeviceShaderImageFootprintFeaturesNV); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR, \
VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR, \
VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, \
VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR, \
VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR, \
VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, \
VkPhysicalDeviceSparseImageFormatInfo2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES, \
VkPhysicalDeviceSubgroupProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT, \
VkPhysicalDeviceSubgroupSizeControlFeaturesEXT) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT, \
VkPhysicalDeviceSubgroupSizeControlPropertiesEXT) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR, \
VkPhysicalDeviceSynchronization2FeaturesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, \
VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT, \
VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, \
VkPhysicalDeviceTimelineSemaphoreFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, \
VkPhysicalDeviceTimelineSemaphoreProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT, \
VkPhysicalDeviceToolPropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, \
VkPhysicalDeviceTransformFeedbackFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT, \
VkPhysicalDeviceTransformFeedbackPropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, \
VkPhysicalDeviceVariablePointerFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, \
VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT, \
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, \
VkPhysicalDeviceUniformBufferStandardLayoutFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES, \
VkPhysicalDeviceVulkan11Features); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES, \
VkPhysicalDeviceVulkan11Properties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES, \
VkPhysicalDeviceVulkan12Features); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES, \
VkPhysicalDeviceVulkan12Properties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, \
VkPhysicalDeviceVulkanMemoryModelFeatures); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR, \
VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT, \
VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, \
VkPhysicalDeviceYcbcrImageArraysFeaturesEXT) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR, \
VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO, VkPipelineCacheCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT, \
VkPipelineCreationFeedbackCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, \
VkPipelineColorBlendStateCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT, \
VkPipelineRasterizationDepthClipStateCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, \
VkPipelineDepthStencilStateCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, \
VkPipelineDiscardRectangleStateCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, \
VkPipelineDynamicStateCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR, \
VkPipelineExecutablePropertiesKHR) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR, VkPipelineExecutableStatisticKHR) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR, \
VkPipelineExecutableInternalRepresentationKHR) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, \
VkPipelineInputAssemblyStateCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, \
VkPipelineMultisampleStateCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, \
VkPipelineRasterizationConservativeStateCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT, \
VkPipelineRasterizationLineStateCreateInfoEXT) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, \
VkPipelineRasterizationStateCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT, \
VkPipelineRasterizationStateStreamCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT, \
VkPipelineSampleLocationsStateCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, VkPipelineShaderStageCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT, \
VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, \
VkPipelineTessellationDomainOriginStateCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, \
VkPipelineTessellationStateCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT, \
VkPipelineVertexInputDivisorStateCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, \
VkPipelineVertexInputStateCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, \
VkPipelineViewportStateCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PRESENT_ID_KHR, VkPresentIdKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR, VkPresentRegionsKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE, VkPresentTimesInfoGOOGLE) \
COPY_STRUCT(VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT, VkPrivateDataSlotCreateInfoEXT) \
COPY_STRUCT(VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, VkQueryPoolCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR, \
VkQueryPoolPerformanceCreateInfoKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, VkQueueFamilyProperties2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, VkRenderPassCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, VkRenderPassCreateInfo2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, \
VkRenderPassFragmentDensityMapCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, \
VkRenderPassInputAttachmentAspectCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, VkRenderPassMultiviewCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT, \
VkRenderPassSampleLocationsBeginInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, VkSampleLocationsInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO, VkSamplerCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT, \
VkSamplerCustomBorderColorCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, \
VkSamplerReductionModeCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, \
VkSamplerYcbcrConversionCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, \
VkSamplerYcbcrConversionImageFormatProperties); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, VkSemaphoreCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, VkSemaphoreTypeCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, VkShaderModuleCreateInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR, \
VkSharedPresentSurfaceCapabilitiesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, VkSparseImageFormatProperties2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, \
VkSparseImageMemoryRequirements2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, VkSubpassBeginInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, VkSubpassDependency2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, VkSubpassDescription2); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, \
VkSubpassDescriptionDepthStencilResolve); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SUBPASS_END_INFO, VkSubpassEndInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, VkSurfaceCapabilities2EXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR, VkSurfaceCapabilities2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR, VkSurfaceFormat2KHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR, \
VkSurfaceProtectedCapabilitiesKHR); \
COPY_STRUCT(VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD, \
VkSwapchainDisplayNativeHdrCreateInfoAMD) \
COPY_STRUCT(VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD, \
VkTextureLODGatherFormatPropertiesAMD); \
COPY_STRUCT(VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, VkTimelineSemaphoreSubmitInfo); \
COPY_STRUCT(VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT, VkValidationCacheCreateInfoEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT, VkValidationFeaturesEXT); \
COPY_STRUCT(VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT, \
VkWriteDescriptorSetInlineUniformBlockEXT); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO, \
VkLayerInstanceCreateInfo); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, VkLayerDeviceCreateInfo); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT, VkDeviceEventInfoEXT); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT, VkDisplayEventInfoEXT); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT, VkDisplayPowerInfoEXT); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, VkExportFenceCreateInfo); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, \
VkExportMemoryAllocateInfo); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV, \
VkExportMemoryAllocateInfoNV); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, \
VkExportSemaphoreCreateInfo); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, VkExternalFenceProperties); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, \
VkExternalMemoryBufferCreateInfo); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, \
VkExternalMemoryImageCreateInfo); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV, \
VkExternalMemoryImageCreateInfoNV); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, \
VkExternalSemaphoreProperties); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR, VkImportMemoryFdInfoKHR); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, VkMemoryFdPropertiesKHR); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, \
VkPhysicalDeviceExternalFenceInfo); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO, VkProtectedSubmitInfo); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT, \
VkShaderModuleValidationCacheCreateInfoEXT); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT, \
VkSwapchainCounterCreateInfoEXT); \
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT, VkValidationFlagsEXT); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, VkBindBufferMemoryInfo, \
UnwrapInPlace(out->buffer), UnwrapInPlace(out->memory)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, VkBindImageMemoryInfo, \
UnwrapInPlace(out->image), UnwrapInPlace(out->memory)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, VkBufferMemoryBarrier, \
UnwrapInPlace(out->buffer)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR, VkBufferMemoryBarrier2KHR, \
UnwrapInPlace(out->buffer)); \
/* VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT aliased by KHR */ \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, VkBufferDeviceAddressInfo, \
UnwrapInPlace(out->buffer)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, \
VkBufferMemoryRequirementsInfo2, UnwrapInPlace(out->buffer)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, VkBufferViewCreateInfo, \
UnwrapInPlace(out->buffer)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, VkCommandBufferAllocateInfo, \
UnwrapInPlace(out->commandPool)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, VkCommandBufferInheritanceInfo, \
UnwrapInPlace(out->renderPass), UnwrapInPlace(out->framebuffer)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR, VkCommandBufferSubmitInfoKHR, \
UnwrapInPlace(out->commandBuffer)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT, \
VkConditionalRenderingBeginInfoEXT, UnwrapInPlace(out->buffer)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET, VkCopyDescriptorSet, \
UnwrapInPlace(out->srcSet), UnwrapInPlace(out->dstSet)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV, \
VkDedicatedAllocationMemoryAllocateInfoNV, UnwrapInPlace(out->buffer), \
UnwrapInPlace(out->image)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, \
VkDescriptorUpdateTemplateCreateInfo, UnwrapInPlace(out->descriptorSetLayout), \
UnwrapInPlace(out->pipelineLayout)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, \
VkDeviceMemoryOpaqueCaptureAddressInfo, UnwrapInPlace(out->memory)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, VkImageMemoryBarrier, \
UnwrapInPlace(out->image)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR, VkImageMemoryBarrier2KHR, \
UnwrapInPlace(out->image)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, \
VkImageMemoryRequirementsInfo2, UnwrapInPlace(out->image)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, \
VkImageSparseMemoryRequirementsInfo2, UnwrapInPlace(out->image)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, VkImageViewCreateInfo, \
UnwrapInPlace(out->image)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, VkMappedMemoryRange, \
UnwrapInPlace(out->memory)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, VkMemoryDedicatedAllocateInfo, \
UnwrapInPlace(out->buffer), UnwrapInPlace(out->image)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, VkPipelineInfoKHR, \
UnwrapInPlace(out->pipeline)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR, VkPipelineExecutableInfoKHR, \
UnwrapInPlace(out->pipeline)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, VkRenderPassBeginInfo, \
UnwrapInPlace(out->renderPass), UnwrapInPlace(out->framebuffer)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, VkSamplerYcbcrConversionInfo, \
UnwrapInPlace(out->conversion)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, VkSemaphoreSignalInfo, \
UnwrapInPlace(out->semaphore)); \
UNWRAP_STRUCT(VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR, VkSemaphoreSubmitInfoKHR, \
UnwrapInPlace(out->semaphore)); \
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR, \
VkAcquireNextImageInfoKHR, UnwrapInPlace(out->swapchain), \
UnwrapInPlace(out->semaphore), UnwrapInPlace(out->fence)); \
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR, \
VkBindImageMemorySwapchainInfoKHR, UnwrapInPlace(out->swapchain)); \
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR, VkFenceGetFdInfoKHR, \
UnwrapInPlace(out->fence)); \
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR, \
VkImageSwapchainCreateInfoKHR, UnwrapInPlace(out->swapchain)); \
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR, VkImportFenceFdInfoKHR, \
UnwrapInPlace(out->fence)); \
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR, \
VkImportSemaphoreFdInfoKHR, UnwrapInPlace(out->semaphore)); \
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, VkMemoryGetFdInfoKHR, \
UnwrapInPlace(out->memory)); \
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, \
VkPhysicalDeviceSurfaceInfo2KHR, UnwrapInPlace(out->surface)); \
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, VkSemaphoreGetFdInfoKHR, \
UnwrapInPlace(out->semaphore)); \
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, VkSwapchainCreateInfoKHR, \
UnwrapInPlace(out->surface), UnwrapInPlace(out->oldSwapchain));
// define cases for structs we don't handle at all - only the body of the case needs to be defined
// per-function.
#define UNHANDLED_STRUCTS() \
/* Surface creation structs would pull in dependencies on OS-specific includes, */ \
/* so we treat them as unsupported. */ \
case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR: \
case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT: \
case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: \
case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: \
case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK: \
case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK: \
case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT: \
case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: \
case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN: \
case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR: \
case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR: \
case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR: \
case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: \
/* Output structure containing objects. Must be *wrapped* not unwrapped. */ \
/* So we treat this as unhandled in generic code and require specific handling. */ \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR: \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR: \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV: \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: \
case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR: \
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: \
case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: \
case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA: \
case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV: \
case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV: \
case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: \
case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: \
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_COMMAND_TRANSFORM_INFO_QCOM: \
case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: \
case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX: \
case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX: \
case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX: \
case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: \
case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: \
case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: \
case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: \
case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: \
case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: \
case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: \
case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV: \
case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: \
case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV: \
case VK_STRUCTURE_TYPE_GEOMETRY_NV: \
case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV: \
case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT: \
case VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA: \
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_FORMAT_CONSTRAINTS_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: \
case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: \
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: \
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: \
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: \
case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL: \
case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV: \
case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: \
case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA: \
case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: \
case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: \
case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL: \
case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL: \
case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: \
case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: \
case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: \
case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: \
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: \
case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: \
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: \
case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: \
case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: \
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: \
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: \
case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: \
case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR: \
case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV: \
case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: \
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_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: \
case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX: \
case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: \
case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: \
case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA: \
case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: \
case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: \
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: \
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
size_t GetNextPatchSize(const void *pNext)
{
const VkBaseInStructure *next = (const VkBaseInStructure *)pNext;
size_t memSize = 0;
while(next)
{
#undef COPY_STRUCT_CAPTURE_ONLY
#define COPY_STRUCT_CAPTURE_ONLY(StructType, StructName) \
case StructType: \
memSize += sizeof(StructName); \
break;
#undef COPY_STRUCT
#define COPY_STRUCT(StructType, StructName) \
case StructType: \
memSize += sizeof(StructName); \
break;
#undef UNWRAP_STRUCT
#define UNWRAP_STRUCT(StructType, StructName, ...) \
case StructType: \
memSize += sizeof(StructName); \
break;
#undef UNWRAP_STRUCT_CAPTURE_ONLY
#define UNWRAP_STRUCT_CAPTURE_ONLY(StructType, StructName, ...) \
case StructType: memSize += sizeof(StructName); break;
switch(next->sType)
{
PROCESS_SIMPLE_STRUCTS();
// complex structs to handle - require multiple allocations
case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
{
memSize += sizeof(VkBindSparseInfo);
VkBindSparseInfo *info = (VkBindSparseInfo *)next;
memSize += info->waitSemaphoreCount * sizeof(VkSemaphore);
memSize += info->signalSemaphoreCount * sizeof(VkSemaphore);
memSize += info->bufferBindCount * sizeof(VkSparseBufferMemoryBindInfo);
memSize += info->imageOpaqueBindCount * sizeof(VkSparseImageOpaqueMemoryBindInfo);
memSize += info->imageBindCount * sizeof(VkSparseImageMemoryBindInfo);
for(uint32_t i = 0; i < info->bufferBindCount; i++)
memSize += info->pBufferBinds[i].bindCount * sizeof(VkSparseMemoryBind);
for(uint32_t i = 0; i < info->imageOpaqueBindCount; i++)
memSize += info->pImageOpaqueBinds[i].bindCount * sizeof(VkSparseMemoryBind);
for(uint32_t i = 0; i < info->imageBindCount; i++)
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_DEPENDENCY_INFO_KHR:
{
memSize += sizeof(VkDependencyInfoKHR);
VkDependencyInfoKHR *info = (VkDependencyInfoKHR *)next;
memSize += info->memoryBarrierCount * sizeof(VkBufferMemoryBarrier2KHR);
for(uint32_t i = 0; i < info->memoryBarrierCount; i++)
memSize += GetNextPatchSize(info->pMemoryBarriers[i].pNext);
memSize += info->bufferMemoryBarrierCount * sizeof(VkBufferMemoryBarrier2KHR);
for(uint32_t i = 0; i < info->bufferMemoryBarrierCount; i++)
memSize += GetNextPatchSize(info->pBufferMemoryBarriers[i].pNext);
memSize += info->imageMemoryBarrierCount * sizeof(VkImageMemoryBarrier2KHR);
for(uint32_t i = 0; i < info->imageMemoryBarrierCount; i++)
memSize += GetNextPatchSize(info->pImageMemoryBarriers[i].pNext);
break;
}
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
{
memSize += sizeof(VkDescriptorSetAllocateInfo);
VkDescriptorSetAllocateInfo *info = (VkDescriptorSetAllocateInfo *)next;
memSize += info->descriptorSetCount * sizeof(VkDescriptorSetLayout);
break;
}
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
{
memSize += sizeof(VkDescriptorSetLayoutCreateInfo);
VkDescriptorSetLayoutCreateInfo *info = (VkDescriptorSetLayoutCreateInfo *)next;
memSize += info->bindingCount * sizeof(VkDescriptorSetLayoutBinding);
for(uint32_t i = 0; i < info->bindingCount; i++)
if(info->pBindings[i].pImmutableSamplers)
memSize += info->pBindings[i].descriptorCount * sizeof(VkSampler);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR:
{
memSize += sizeof(VkDeviceBufferMemoryRequirementsKHR);
VkDeviceBufferMemoryRequirementsKHR *info = (VkDeviceBufferMemoryRequirementsKHR *)next;
memSize += GetNextPatchSize(info->pCreateInfo);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
{
memSize += sizeof(VkDeviceGroupDeviceCreateInfo);
VkDeviceGroupDeviceCreateInfo *info = (VkDeviceGroupDeviceCreateInfo *)next;
memSize += info->physicalDeviceCount * sizeof(VkPhysicalDevice);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR:
{
memSize += sizeof(VkDeviceImageMemoryRequirementsKHR);
VkDeviceImageMemoryRequirementsKHR *info = (VkDeviceImageMemoryRequirementsKHR *)next;
memSize += GetNextPatchSize(info->pCreateInfo);
break;
}
case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
{
memSize += sizeof(VkFramebufferCreateInfo);
VkFramebufferCreateInfo *info = (VkFramebufferCreateInfo *)next;
memSize += info->attachmentCount * sizeof(VkImageView);
break;
}
// this struct doesn't really need to be unwrapped but we allocate space for it since it
// contains arrays that we will very commonly need to patch, to adjust image info/formats.
// this saves us needing to iterate it outside and allocate extra space
case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
{
memSize += sizeof(VkFramebufferAttachmentsCreateInfo);
VkFramebufferAttachmentsCreateInfo *info = (VkFramebufferAttachmentsCreateInfo *)next;
memSize += info->attachmentImageInfoCount * sizeof(VkFramebufferAttachmentImageInfo);
for(uint32_t i = 0; i < info->attachmentImageInfoCount; i++)
memSize += GetNextPatchSize(&info->pAttachmentImageInfos[i]);
break;
}
case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO:
{
memSize += sizeof(VkFramebufferAttachmentImageInfo);
// we add space for an extra VkFormat so we can push one onto the list
VkFramebufferAttachmentImageInfo *info = (VkFramebufferAttachmentImageInfo *)next;
if(info->viewFormatCount > 0)
memSize += (info->viewFormatCount + 1) * sizeof(VkFormat);
break;
}
case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
{
memSize += sizeof(VkGraphicsPipelineCreateInfo);
VkGraphicsPipelineCreateInfo *info = (VkGraphicsPipelineCreateInfo *)next;
memSize += info->stageCount * sizeof(VkPipelineShaderStageCreateInfo);
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:
{
memSize += sizeof(VkPipelineLayoutCreateInfo);
VkPipelineLayoutCreateInfo *info = (VkPipelineLayoutCreateInfo *)next;
memSize += info->setLayoutCount * sizeof(VkDescriptorSetLayout);
break;
}
case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
{
memSize += sizeof(VkPresentInfoKHR);
VkPresentInfoKHR *info = (VkPresentInfoKHR *)next;
memSize += info->waitSemaphoreCount * sizeof(VkSemaphore);
memSize += info->swapchainCount * sizeof(VkSwapchainKHR);
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
{
memSize += sizeof(VkRenderPassAttachmentBeginInfo);
VkRenderPassAttachmentBeginInfo *info = (VkRenderPassAttachmentBeginInfo *)next;
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);
VkSemaphoreWaitInfo *info = (VkSemaphoreWaitInfo *)next;
memSize += info->semaphoreCount * sizeof(VkSemaphore);
break;
}
case VK_STRUCTURE_TYPE_SUBMIT_INFO:
{
memSize += sizeof(VkSubmitInfo);
VkSubmitInfo *info = (VkSubmitInfo *)next;
memSize += info->waitSemaphoreCount * sizeof(VkSemaphore);
memSize += info->commandBufferCount * sizeof(VkCommandBuffer);
memSize += info->signalSemaphoreCount * sizeof(VkSemaphore);
break;
}
case VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR:
{
memSize += sizeof(VkSubmitInfo2KHR);
VkSubmitInfo2KHR *info = (VkSubmitInfo2KHR *)next;
memSize += info->waitSemaphoreInfoCount * sizeof(VkSemaphoreSubmitInfoKHR);
for(uint32_t i = 0; i < info->waitSemaphoreInfoCount; i++)
memSize += GetNextPatchSize(info->pWaitSemaphoreInfos[i].pNext);
memSize += info->commandBufferInfoCount * sizeof(VkCommandBufferSubmitInfoKHR);
for(uint32_t i = 0; i < info->commandBufferInfoCount; i++)
memSize += GetNextPatchSize(info->pCommandBufferInfos[i].pNext);
memSize += info->signalSemaphoreInfoCount * sizeof(VkSemaphoreSubmitInfoKHR);
for(uint32_t i = 0; i < info->signalSemaphoreInfoCount; i++)
memSize += GetNextPatchSize(info->pSignalSemaphoreInfos[i].pNext);
break;
}
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
{
memSize += sizeof(VkWriteDescriptorSet);
VkWriteDescriptorSet *info = (VkWriteDescriptorSet *)next;
switch(info->descriptorType)
{
case VK_DESCRIPTOR_TYPE_SAMPLER:
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
memSize += info->descriptorCount * sizeof(VkDescriptorImageInfo);
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
memSize += info->descriptorCount * sizeof(VkBufferView);
break;
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
memSize += info->descriptorCount * sizeof(VkDescriptorBufferInfo);
break;
case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
// nothing to unwrap for inline uniform blocks, it's on the next chain
break;
default: RDCERR("Unhandled descriptor type unwrapping VkWriteDescriptorSet"); break;
}
break;
}
// Android External Buffer Memory Extension
#if ENABLED(RDOC_ANDROID)
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
VkImportAndroidHardwareBufferInfoANDROID);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID,
VkAndroidHardwareBufferUsageANDROID);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VkExternalFormatANDROID);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
VkAndroidHardwareBufferFormatPropertiesANDROID);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
VkAndroidHardwareBufferPropertiesANDROID);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
VkMemoryGetAndroidHardwareBufferInfoANDROID);
#else
case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID:
{
RDCERR("Support for android external memory buffer extension not compiled in");
break;
}
#endif
#if ENABLED(RDOC_GGP)
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP, VkPresentFrameTokenGGP);
#else
case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
{
RDCERR("Support for GGP frame token extension not compiled in");
break;
}
#endif
// NV win32 external memory extensions
#if ENABLED(RDOC_WIN32)
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
VkImportMemoryWin32HandleInfoNV);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
VkExportMemoryWin32HandleInfoNV);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
VkImportMemoryWin32HandleInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
VkExportMemoryWin32HandleInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR,
VkMemoryWin32HandlePropertiesKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
VkExportSemaphoreWin32HandleInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR,
VkD3D12FenceSubmitInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR,
VkExportFenceWin32HandleInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT,
VkSurfaceFullScreenExclusiveWin32InfoEXT);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT,
VkSurfaceCapabilitiesFullScreenExclusiveEXT);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT,
VkSurfaceFullScreenExclusiveInfoEXT);
case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
memSize += sizeof(VkMemoryGetWin32HandleInfoKHR);
break;
case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
memSize += sizeof(VkImportSemaphoreWin32HandleInfoKHR);
break;
case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
memSize += sizeof(VkSemaphoreGetWin32HandleInfoKHR);
break;
case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
memSize += sizeof(VkImportFenceWin32HandleInfoKHR);
break;
case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
memSize += sizeof(VkFenceGetWin32HandleInfoKHR);
break;
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
{
// the KHR and NV structs are identical
memSize += sizeof(VkWin32KeyedMutexAcquireReleaseInfoKHR);
VkWin32KeyedMutexAcquireReleaseInfoKHR *info = (VkWin32KeyedMutexAcquireReleaseInfoKHR *)next;
memSize += info->acquireCount * sizeof(VkDeviceMemory);
memSize += info->releaseCount * sizeof(VkDeviceMemory);
break;
}
#else
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:
case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
{
RDCERR("Support for win32 external memory extensions not compiled in");
break;
}
#endif
case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:
case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:
case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT:
case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT:
{
// could be implemented but would need extra work or doesn't make sense right now
RDCERR("Struct %s not handled in pNext chain", ToStr(next->sType).c_str());
break;
}
UNHANDLED_STRUCTS()
{
RDCERR("Unhandled struct %s in pNext chain", ToStr(next->sType).c_str());
break;
}
case VK_STRUCTURE_TYPE_MAX_ENUM:
RDCERR("Invalid value %u in pNext chain", next->sType);
break;
}
next = next->pNext;
}
return memSize;
}
void UnwrapNextChain(CaptureState state, const char *structName, byte *&tempMem,
VkBaseInStructure *infoStruct)
{
// during capture, this walks the pNext chain and either copies structs that can be passed
// straight through, or copies and modifies any with vulkan objects that need to be unwrapped.
//
// during replay, we do the same thing to prepare for dispatching to the driver, but we also strip
// out any structs we don't want to replay - e.g. external memory. This means the data is
// serialised and available for future use and for user inspection, but isn't replayed when not
// necesary.
VkBaseInStructure *nextChainTail = infoStruct;
const VkBaseInStructure *nextInput = (const VkBaseInStructure *)infoStruct->pNext;
#undef COPY_STRUCT_CAPTURE_ONLY
#define COPY_STRUCT_CAPTURE_ONLY(StructType, StructName) \
case StructType: \
{ \
if(IsCaptureMode(state)) \
CopyNextChainedStruct(sizeof(StructName), tempMem, nextInput, nextChainTail); \
break; \
}
#undef COPY_STRUCT
#define COPY_STRUCT(StructType, StructName) \
case StructType: \
{ \
CopyNextChainedStruct(sizeof(StructName), tempMem, nextInput, nextChainTail); \
break; \
}
#undef UNWRAP_STRUCT_INNER
#define UNWRAP_STRUCT_INNER(StructType, StructName, ...) \
{ \
const StructName *in = (const StructName *)nextInput; \
StructName *out = (StructName *)tempMem; \
\
/* copy the struct */ \
*out = *in; \
/* abuse comma operator to unwrap all members */ \
__VA_ARGS__; \
\
AppendModifiedChainedStruct(tempMem, out, nextChainTail); \
}
#undef UNWRAP_STRUCT
#define UNWRAP_STRUCT(StructType, StructName, ...) \
case StructType: \
{ \
UNWRAP_STRUCT_INNER(StructType, StructName, __VA_ARGS__) \
break; \
}
#undef UNWRAP_STRUCT_CAPTURE_ONLY
#define UNWRAP_STRUCT_CAPTURE_ONLY(StructType, StructName, ...) \
case StructType: \
{ \
if(IsCaptureMode(state)) \
{ \
UNWRAP_STRUCT_INNER(StructType, StructName, __VA_ARGS__) \
} \
break; \
}
// start with an empty chain. Every call to AppendModifiedChainedStruct / CopyNextChainedStruct
// pushes on a new entry, but if there's only one entry in the list and it's one we want to skip,
// this needs to start at NULL.
nextChainTail->pNext = NULL;
while(nextInput)
{
switch(nextInput->sType)
{
PROCESS_SIMPLE_STRUCTS();
// complex structs to handle - require multiple allocations
case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:
{
const VkBindSparseInfo *in = (const VkBindSparseInfo *)nextInput;
VkBindSparseInfo *out = (VkBindSparseInfo *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped arrays
VkSemaphore *outWaitSemaphores = (VkSemaphore *)tempMem;
tempMem += sizeof(VkSemaphore) * in->waitSemaphoreCount;
VkSemaphore *outSignalSemaphores = (VkSemaphore *)tempMem;
tempMem += sizeof(VkSemaphore) * in->signalSemaphoreCount;
VkSparseBufferMemoryBindInfo *outBufferBinds = (VkSparseBufferMemoryBindInfo *)tempMem;
tempMem += sizeof(VkSparseBufferMemoryBindInfo) * in->bufferBindCount;
VkSparseImageOpaqueMemoryBindInfo *outImageOpaqueBinds =
(VkSparseImageOpaqueMemoryBindInfo *)tempMem;
tempMem += sizeof(VkSparseImageOpaqueMemoryBindInfo) * in->imageOpaqueBindCount;
VkSparseImageMemoryBindInfo *outImageBinds = (VkSparseImageMemoryBindInfo *)tempMem;
tempMem += sizeof(VkSparseImageMemoryBindInfo) * in->imageBindCount;
*out = *in;
out->pWaitSemaphores = outWaitSemaphores;
out->pSignalSemaphores = outSignalSemaphores;
out->pBufferBinds = outBufferBinds;
out->pImageOpaqueBinds = outImageOpaqueBinds;
out->pImageBinds = outImageBinds;
for(uint32_t i = 0; i < in->waitSemaphoreCount; i++)
outWaitSemaphores[i] = Unwrap(in->pWaitSemaphores[i]);
for(uint32_t i = 0; i < in->signalSemaphoreCount; i++)
outSignalSemaphores[i] = Unwrap(in->pSignalSemaphores[i]);
VkSparseMemoryBind *outMemoryBinds = (VkSparseMemoryBind *)tempMem;
for(uint32_t i = 0; i < in->bufferBindCount; i++)
{
outBufferBinds[i] = in->pBufferBinds[i];
UnwrapInPlace(outBufferBinds[i].buffer);
outBufferBinds[i].pBinds = outMemoryBinds;
for(uint32_t b = 0; b < outBufferBinds[i].bindCount; b++)
{
outMemoryBinds[b] = in->pBufferBinds[i].pBinds[b];
UnwrapInPlace(outMemoryBinds[b].memory);
}
outMemoryBinds += outBufferBinds[i].bindCount;
tempMem += outBufferBinds[i].bindCount * sizeof(VkSparseMemoryBind);
}
for(uint32_t i = 0; i < in->imageOpaqueBindCount; i++)
{
outImageOpaqueBinds[i] = in->pImageOpaqueBinds[i];
UnwrapInPlace(outImageOpaqueBinds[i].image);
outImageOpaqueBinds[i].pBinds = outMemoryBinds;
for(uint32_t b = 0; b < outBufferBinds[i].bindCount; b++)
{
outMemoryBinds[b] = in->pImageOpaqueBinds[i].pBinds[b];
UnwrapInPlace(outMemoryBinds[b].memory);
}
outMemoryBinds += outImageOpaqueBinds[i].bindCount;
tempMem += outImageOpaqueBinds[i].bindCount * sizeof(VkSparseMemoryBind);
}
VkSparseImageMemoryBind *outImageMemoryBinds = (VkSparseImageMemoryBind *)tempMem;
for(uint32_t i = 0; i < in->imageBindCount; i++)
{
outImageBinds[i] = in->pImageBinds[i];
UnwrapInPlace(outImageBinds[i].image);
outImageBinds[i].pBinds = outImageMemoryBinds;
for(uint32_t b = 0; b < outBufferBinds[i].bindCount; b++)
{
outImageMemoryBinds[b] = in->pImageBinds[i].pBinds[b];
UnwrapInPlace(outImageMemoryBinds[b].memory);
}
outImageMemoryBinds += outImageBinds[i].bindCount;
tempMem += outImageBinds[i].bindCount * sizeof(VkSparseMemoryBind);
}
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_DEPENDENCY_INFO_KHR:
{
const VkDependencyInfoKHR *in = (const VkDependencyInfoKHR *)nextInput;
VkDependencyInfoKHR *out = (VkDependencyInfoKHR *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped arrays
VkMemoryBarrier2KHR *outMemoryBarriers = (VkMemoryBarrier2KHR *)tempMem;
tempMem += sizeof(VkMemoryBarrier2KHR) * in->memoryBarrierCount;
VkBufferMemoryBarrier2KHR *outBufferBarriers = (VkBufferMemoryBarrier2KHR *)tempMem;
tempMem += sizeof(VkBufferMemoryBarrier2KHR) * in->bufferMemoryBarrierCount;
VkImageMemoryBarrier2KHR *outImageBarriers = (VkImageMemoryBarrier2KHR *)tempMem;
tempMem += sizeof(VkImageMemoryBarrier2KHR) * in->imageMemoryBarrierCount;
*out = *in;
out->pMemoryBarriers = outMemoryBarriers;
out->pBufferMemoryBarriers = outBufferBarriers;
out->pImageMemoryBarriers = outImageBarriers;
for(uint32_t i = 0; i < in->memoryBarrierCount; i++)
{
outMemoryBarriers[i] = in->pMemoryBarriers[i];
UnwrapNextChain(state, "VkMemoryBarrier2KHR", tempMem,
(VkBaseInStructure *)&outMemoryBarriers[i]);
}
for(uint32_t i = 0; i < in->bufferMemoryBarrierCount; i++)
{
outBufferBarriers[i] = in->pBufferMemoryBarriers[i];
UnwrapInPlace(outBufferBarriers[i].buffer);
UnwrapNextChain(state, "VkBufferMemoryBarrier2KHR", tempMem,
(VkBaseInStructure *)&outBufferBarriers[i]);
}
for(uint32_t i = 0; i < in->imageMemoryBarrierCount; i++)
{
outImageBarriers[i] = in->pImageMemoryBarriers[i];
UnwrapInPlace(outImageBarriers[i].image);
UnwrapNextChain(state, "VkImageMemoryBarrier2KHR", tempMem,
(VkBaseInStructure *)&outImageBarriers[i]);
}
break;
}
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
{
const VkDescriptorSetAllocateInfo *in = (const VkDescriptorSetAllocateInfo *)nextInput;
VkDescriptorSetAllocateInfo *out = (VkDescriptorSetAllocateInfo *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkDescriptorSetLayout *outLayouts = (VkDescriptorSetLayout *)tempMem;
tempMem += sizeof(VkDescriptorSetLayout) * in->descriptorSetCount;
*out = *in;
UnwrapInPlace(out->descriptorPool);
out->pSetLayouts = outLayouts;
for(uint32_t i = 0; i < in->descriptorSetCount; i++)
outLayouts[i] = Unwrap(in->pSetLayouts[i]);
break;
}
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
{
const VkDescriptorSetLayoutCreateInfo *in =
(const VkDescriptorSetLayoutCreateInfo *)nextInput;
VkDescriptorSetLayoutCreateInfo *out = (VkDescriptorSetLayoutCreateInfo *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkDescriptorSetLayoutBinding *outBindings = (VkDescriptorSetLayoutBinding *)tempMem;
tempMem += sizeof(VkDescriptorSetLayoutBinding) * in->bindingCount;
VkSampler *outSamplers = (VkSampler *)tempMem;
*out = *in;
out->pBindings = outBindings;
for(uint32_t i = 0; i < out->bindingCount; i++)
{
outBindings[i] = in->pBindings[i];
if(outBindings[i].pImmutableSamplers)
{
outBindings[i].pImmutableSamplers = outSamplers;
for(uint32_t d = 0; d < out->pBindings[i].descriptorCount; d++)
outSamplers[d] = Unwrap(in->pBindings[i].pImmutableSamplers[d]);
tempMem += sizeof(VkSampler) * out->pBindings[i].descriptorCount;
outSamplers += out->pBindings[i].descriptorCount;
}
}
break;
}
case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR:
{
const VkDeviceBufferMemoryRequirementsKHR *in =
(const VkDeviceBufferMemoryRequirementsKHR *)nextInput;
VkDeviceBufferMemoryRequirementsKHR *out = (VkDeviceBufferMemoryRequirementsKHR *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
out->sType = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR;
out->pNext = in->pNext;
out->pCreateInfo = AllocStructCopy(tempMem, in->pCreateInfo);
UnwrapNextChain(state, "VkBufferCreateInfo", tempMem, (VkBaseInStructure *)out->pCreateInfo);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
{
const VkDeviceGroupDeviceCreateInfo *in = (const VkDeviceGroupDeviceCreateInfo *)nextInput;
VkDeviceGroupDeviceCreateInfo *out = (VkDeviceGroupDeviceCreateInfo *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkPhysicalDevice *outDevices = (VkPhysicalDevice *)tempMem;
tempMem += sizeof(VkPhysicalDevice) * in->physicalDeviceCount;
*out = *in;
out->pPhysicalDevices = outDevices;
for(uint32_t i = 0; i < in->physicalDeviceCount; i++)
outDevices[i] = Unwrap(in->pPhysicalDevices[i]);
break;
}
case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR:
{
const VkDeviceImageMemoryRequirementsKHR *in =
(const VkDeviceImageMemoryRequirementsKHR *)nextInput;
VkDeviceImageMemoryRequirementsKHR *out = (VkDeviceImageMemoryRequirementsKHR *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
out->sType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR;
out->pNext = in->pNext;
out->planeAspect = in->planeAspect;
out->pCreateInfo = AllocStructCopy(tempMem, in->pCreateInfo);
UnwrapNextChain(state, "VkImageCreateInfo", tempMem, (VkBaseInStructure *)out->pCreateInfo);
break;
}
case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
{
const VkFramebufferCreateInfo *in = (const VkFramebufferCreateInfo *)nextInput;
VkFramebufferCreateInfo *out = (VkFramebufferCreateInfo *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkImageView *outAttachments = (VkImageView *)tempMem;
tempMem += sizeof(VkImageView) * in->attachmentCount;
*out = *in;
UnwrapInPlace(out->renderPass);
if((out->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT) == 0)
{
out->pAttachments = outAttachments;
for(uint32_t i = 0; i < in->attachmentCount; i++)
outAttachments[i] = Unwrap(in->pAttachments[i]);
}
break;
}
// this struct doesn't really need to be unwrapped but we allocate space for it since it
// contains arrays that we will very commonly need to patch, to adjust image info/formats.
// this saves us needing to iterate it outside and allocate extra space
case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
{
const VkFramebufferAttachmentsCreateInfo *in =
(const VkFramebufferAttachmentsCreateInfo *)nextInput;
VkFramebufferAttachmentsCreateInfo *out = (VkFramebufferAttachmentsCreateInfo *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkFramebufferAttachmentImageInfo *outAtts = (VkFramebufferAttachmentImageInfo *)tempMem;
tempMem += sizeof(VkFramebufferAttachmentImageInfo) * in->attachmentImageInfoCount;
*out = *in;
out->pAttachmentImageInfos = outAtts;
for(uint32_t i = 0; i < in->attachmentImageInfoCount; i++)
{
outAtts[i] = in->pAttachmentImageInfos[i];
UnwrapNextChain(state, "VkFramebufferAttachmentImageInfo", tempMem,
(VkBaseInStructure *)&outAtts[i]);
}
break;
}
case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO:
{
const VkFramebufferAttachmentImageInfo *in =
(const VkFramebufferAttachmentImageInfo *)nextInput;
VkFramebufferAttachmentImageInfo *out = (VkFramebufferAttachmentImageInfo *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
*out = *in;
// allocate extra array
if(in->viewFormatCount > 0)
{
VkFormat *outFormats = (VkFormat *)tempMem;
tempMem += sizeof(VkFormat) * (in->viewFormatCount + 1);
out->pViewFormats = outFormats;
memcpy(outFormats, in->pViewFormats, sizeof(VkFormat) * in->viewFormatCount);
}
break;
}
case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
{
const VkGraphicsPipelineCreateInfo *in = (const VkGraphicsPipelineCreateInfo *)nextInput;
VkGraphicsPipelineCreateInfo *out = (VkGraphicsPipelineCreateInfo *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkPipelineShaderStageCreateInfo *outShaders = (VkPipelineShaderStageCreateInfo *)tempMem;
tempMem += sizeof(VkPipelineShaderStageCreateInfo) * in->stageCount;
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]);
}
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);
UnwrapInPlace(out->layout);
UnwrapInPlace(out->renderPass);
out->subpass = in->subpass;
if(out->flags & VK_PIPELINE_CREATE_DERIVATIVE_BIT)
UnwrapInPlace(out->basePipelineHandle);
else
out->basePipelineHandle = VK_NULL_HANDLE;
out->basePipelineIndex = in->basePipelineIndex;
break;
}
case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
{
const VkPipelineLayoutCreateInfo *in = (const VkPipelineLayoutCreateInfo *)nextInput;
VkPipelineLayoutCreateInfo *out = (VkPipelineLayoutCreateInfo *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkDescriptorSetLayout *outLayouts = (VkDescriptorSetLayout *)tempMem;
tempMem += sizeof(VkDescriptorSetLayout) * in->setLayoutCount;
*out = *in;
out->pSetLayouts = outLayouts;
for(uint32_t i = 0; i < in->setLayoutCount; i++)
outLayouts[i] = Unwrap(in->pSetLayouts[i]);
break;
}
case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
{
const VkPresentInfoKHR *in = (const VkPresentInfoKHR *)nextInput;
VkPresentInfoKHR *out = (VkPresentInfoKHR *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped arrays
VkSemaphore *outWaitSemaphores = (VkSemaphore *)tempMem;
tempMem += sizeof(VkSemaphore) * in->waitSemaphoreCount;
VkSwapchainKHR *outSwapchains = (VkSwapchainKHR *)tempMem;
tempMem += sizeof(VkSwapchainKHR) * in->swapchainCount;
*out = *in;
out->pSwapchains = outSwapchains;
out->pWaitSemaphores = outWaitSemaphores;
for(uint32_t i = 0; i < in->swapchainCount; i++)
outSwapchains[i] = Unwrap(in->pSwapchains[i]);
for(uint32_t i = 0; i < in->waitSemaphoreCount; i++)
outWaitSemaphores[i] = Unwrap(in->pWaitSemaphores[i]);
break;
}
case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
{
const VkRenderPassAttachmentBeginInfo *in =
(const VkRenderPassAttachmentBeginInfo *)nextInput;
VkRenderPassAttachmentBeginInfo *out = (VkRenderPassAttachmentBeginInfo *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkImageView *outAttachments = (VkImageView *)tempMem;
tempMem += sizeof(VkImageView) * in->attachmentCount;
*out = *in;
out->pAttachments = outAttachments;
for(uint32_t i = 0; i < in->attachmentCount; i++)
outAttachments[i] = Unwrap(in->pAttachments[i]);
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;
VkSemaphoreWaitInfo *out = (VkSemaphoreWaitInfo *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped array
VkSemaphore *outSemaphores = (VkSemaphore *)tempMem;
tempMem += sizeof(VkSemaphore) * in->semaphoreCount;
*out = *in;
out->pSemaphores = outSemaphores;
for(uint32_t i = 0; i < in->semaphoreCount; i++)
outSemaphores[i] = Unwrap(in->pSemaphores[i]);
break;
}
case VK_STRUCTURE_TYPE_SUBMIT_INFO:
{
const VkSubmitInfo *in = (const VkSubmitInfo *)nextInput;
VkSubmitInfo *out = (VkSubmitInfo *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped arrays
VkSemaphore *outWaitSemaphores = (VkSemaphore *)tempMem;
tempMem += sizeof(VkSemaphore) * in->waitSemaphoreCount;
VkCommandBuffer *outCmdBuffers = (VkCommandBuffer *)tempMem;
tempMem += sizeof(VkCommandBuffer) * in->commandBufferCount;
VkSemaphore *outSignalSemaphores = (VkSemaphore *)tempMem;
tempMem += sizeof(VkSemaphore) * in->signalSemaphoreCount;
*out = *in;
out->pWaitSemaphores = outWaitSemaphores;
out->pCommandBuffers = outCmdBuffers;
out->pSignalSemaphores = outSignalSemaphores;
for(uint32_t i = 0; i < in->waitSemaphoreCount; i++)
outWaitSemaphores[i] = Unwrap(in->pWaitSemaphores[i]);
for(uint32_t i = 0; i < in->commandBufferCount; i++)
outCmdBuffers[i] = Unwrap(in->pCommandBuffers[i]);
for(uint32_t i = 0; i < in->signalSemaphoreCount; i++)
outSignalSemaphores[i] = Unwrap(in->pSignalSemaphores[i]);
break;
}
case VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR:
{
const VkSubmitInfo2KHR *in = (const VkSubmitInfo2KHR *)nextInput;
VkSubmitInfo2KHR *out = (VkSubmitInfo2KHR *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// allocate unwrapped arrays
VkSemaphoreSubmitInfoKHR *outWaitSemaphores = (VkSemaphoreSubmitInfoKHR *)tempMem;
tempMem += sizeof(VkSemaphoreSubmitInfoKHR) * in->waitSemaphoreInfoCount;
VkCommandBufferSubmitInfoKHR *outCmdBuffers = (VkCommandBufferSubmitInfoKHR *)tempMem;
tempMem += sizeof(VkCommandBufferSubmitInfoKHR) * in->commandBufferInfoCount;
VkSemaphoreSubmitInfoKHR *outSignalSemaphores = (VkSemaphoreSubmitInfoKHR *)tempMem;
tempMem += sizeof(VkSemaphoreSubmitInfoKHR) * in->signalSemaphoreInfoCount;
*out = *in;
out->pWaitSemaphoreInfos = outWaitSemaphores;
out->pCommandBufferInfos = outCmdBuffers;
out->pSignalSemaphoreInfos = outSignalSemaphores;
for(uint32_t i = 0; i < in->waitSemaphoreInfoCount; i++)
{
outWaitSemaphores[i] = in->pWaitSemaphoreInfos[i];
UnwrapInPlace(outWaitSemaphores[i].semaphore);
UnwrapNextChain(state, "VkSemaphoreSubmitInfoKHR", tempMem,
(VkBaseInStructure *)&outWaitSemaphores[i]);
}
for(uint32_t i = 0; i < in->commandBufferInfoCount; i++)
{
outCmdBuffers[i] = in->pCommandBufferInfos[i];
UnwrapInPlace(outCmdBuffers[i].commandBuffer);
UnwrapNextChain(state, "VkCommandBufferSubmitInfoKHR", tempMem,
(VkBaseInStructure *)&outCmdBuffers[i]);
}
for(uint32_t i = 0; i < in->signalSemaphoreInfoCount; i++)
{
outSignalSemaphores[i] = in->pSignalSemaphoreInfos[i];
UnwrapInPlace(outSignalSemaphores[i].semaphore);
UnwrapNextChain(state, "VkSemaphoreSubmitInfoKHR", tempMem,
(VkBaseInStructure *)&outSignalSemaphores[i]);
}
break;
}
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
{
const VkWriteDescriptorSet *in = (const VkWriteDescriptorSet *)nextInput;
VkWriteDescriptorSet *out = (VkWriteDescriptorSet *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
*out = *in;
UnwrapInPlace(out->dstSet);
switch(out->descriptorType)
{
case VK_DESCRIPTOR_TYPE_SAMPLER:
case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
{
VkDescriptorImageInfo *outBindings = (VkDescriptorImageInfo *)tempMem;
tempMem += sizeof(VkDescriptorImageInfo) * in->descriptorCount;
for(uint32_t d = 0; d < in->descriptorCount; d++)
{
outBindings[d] = in->pImageInfo[d];
UnwrapInPlace(outBindings[d].imageView);
UnwrapInPlace(outBindings[d].sampler);
}
break;
}
case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
{
VkBufferView *outBindings = (VkBufferView *)tempMem;
tempMem += sizeof(VkBufferView) * in->descriptorCount;
for(uint32_t d = 0; d < in->descriptorCount; d++)
outBindings[d] = Unwrap(in->pTexelBufferView[d]);
break;
}
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
{
VkDescriptorBufferInfo *outBindings = (VkDescriptorBufferInfo *)tempMem;
tempMem += sizeof(VkDescriptorBufferInfo) * in->descriptorCount;
for(uint32_t d = 0; d < in->descriptorCount; d++)
{
outBindings[d] = in->pBufferInfo[d];
UnwrapInPlace(outBindings[d].buffer);
}
break;
}
case VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT:
{
// nothing to do/patch
break;
}
default: RDCERR("Unhandled descriptor type unwrapping VkWriteDescriptorSet"); break;
}
break;
}
// Android External Buffer Memory Extension
#if ENABLED(RDOC_ANDROID)
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
VkImportAndroidHardwareBufferInfoANDROID);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID,
VkAndroidHardwareBufferUsageANDROID);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VkExternalFormatANDROID);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
VkAndroidHardwareBufferFormatPropertiesANDROID);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
VkAndroidHardwareBufferPropertiesANDROID);
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
VkMemoryGetAndroidHardwareBufferInfoANDROID,
UnwrapInPlace(out->memory));
#else
case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID:
{
RDCERR("Support for android external memory buffer extension not compiled in");
break;
}
#endif
#if ENABLED(RDOC_GGP)
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP, VkPresentFrameTokenGGP);
#else
case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
{
RDCERR("Support for GGP frame token extension not compiled in");
break;
}
#endif
// NV win32 external memory extensions
#if ENABLED(RDOC_WIN32)
// Structs that can be copied into place
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
VkImportMemoryWin32HandleInfoNV);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
VkExportMemoryWin32HandleInfoNV);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
VkImportMemoryWin32HandleInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
VkExportMemoryWin32HandleInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR,
VkMemoryWin32HandlePropertiesKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
VkExportSemaphoreWin32HandleInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR,
VkD3D12FenceSubmitInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR,
VkExportFenceWin32HandleInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT,
VkSurfaceFullScreenExclusiveWin32InfoEXT);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT,
VkSurfaceCapabilitiesFullScreenExclusiveEXT);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT,
VkSurfaceFullScreenExclusiveInfoEXT);
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR,
VkMemoryGetWin32HandleInfoKHR, UnwrapInPlace(out->memory));
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
VkImportSemaphoreWin32HandleInfoKHR,
UnwrapInPlace(out->semaphore));
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
VkSemaphoreGetWin32HandleInfoKHR, UnwrapInPlace(out->semaphore));
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR,
VkImportFenceWin32HandleInfoKHR, UnwrapInPlace(out->fence));
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR,
VkFenceGetWin32HandleInfoKHR, UnwrapInPlace(out->fence));
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
{
// strip during replay
if(IsCaptureMode(state))
{
// KHR and NV structs are identical
const VkWin32KeyedMutexAcquireReleaseInfoKHR *in =
(const VkWin32KeyedMutexAcquireReleaseInfoKHR *)nextInput;
VkWin32KeyedMutexAcquireReleaseInfoKHR *out =
(VkWin32KeyedMutexAcquireReleaseInfoKHR *)tempMem;
// append immediately so tempMem is incremented
AppendModifiedChainedStruct(tempMem, out, nextChainTail);
// copy struct across
*out = *in;
// allocate unwrapped arrays
VkDeviceMemory *unwrappedAcquires = (VkDeviceMemory *)tempMem;
tempMem += sizeof(VkDeviceMemory) * in->acquireCount;
VkDeviceMemory *unwrappedReleases = (VkDeviceMemory *)tempMem;
tempMem += sizeof(VkDeviceMemory) * in->releaseCount;
// unwrap the arrays
for(uint32_t mem = 0; mem < in->acquireCount; mem++)
unwrappedAcquires[mem] = Unwrap(in->pAcquireSyncs[mem]);
for(uint32_t mem = 0; mem < in->releaseCount; mem++)
unwrappedReleases[mem] = Unwrap(in->pReleaseSyncs[mem]);
out->pAcquireSyncs = unwrappedAcquires;
out->pReleaseSyncs = unwrappedReleases;
}
break;
}
#else
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:
case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
{
RDCERR("Support for win32 external memory extensions not compiled in");
nextChainTail->pNext = nextInput;
break;
}
#endif
case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:
case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:
case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT:
case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT:
{
// could be implemented but would need extra work or doesn't make sense right now
RDCERR("Struct %s not handled in %s pNext chain", ToStr(nextInput->sType).c_str(),
structName);
nextChainTail->pNext = nextInput;
break;
}
UNHANDLED_STRUCTS()
{
RDCERR("Unhandled struct %s in %s pNext chain", ToStr(nextInput->sType).c_str(),
structName);
nextChainTail->pNext = nextInput;
break;
}
case VK_STRUCTURE_TYPE_MAX_ENUM:
{
RDCERR("Invalid value %x in %s pNext chain", nextInput->sType, structName);
nextChainTail->pNext = nextInput;
break;
}
}
nextInput = nextInput->pNext;
}
}
void CopyNextChainForPatching(const char *structName, byte *&tempMem, VkBaseInStructure *infoStruct)
{
VkBaseInStructure *nextChainTail = infoStruct;
const VkBaseInStructure *nextInput = (const VkBaseInStructure *)infoStruct->pNext;
// simplified version of UnwrapNextChain which just copies everything. Useful for when we need to
// shallow duplicate a next chain (e.g. because we'll copy and patch one struct)
#undef COPY_STRUCT_CAPTURE_ONLY
#define COPY_STRUCT_CAPTURE_ONLY(StructType, StructName) \
case StructType: \
CopyNextChainedStruct(sizeof(StructName), tempMem, nextInput, nextChainTail); \
break;
#undef COPY_STRUCT
#define COPY_STRUCT(StructType, StructName) \
case StructType: \
CopyNextChainedStruct(sizeof(StructName), tempMem, nextInput, nextChainTail); \
break;
#undef UNWRAP_STRUCT_INNER
#define UNWRAP_STRUCT_INNER(StructType, StructName, ...) \
case StructType: \
CopyNextChainedStruct(sizeof(StructName), tempMem, nextInput, nextChainTail); \
break;
#undef UNWRAP_STRUCT
#define UNWRAP_STRUCT(StructType, StructName, ...) \
case StructType: \
CopyNextChainedStruct(sizeof(StructName), tempMem, nextInput, nextChainTail); \
break;
#undef UNWRAP_STRUCT_CAPTURE_ONLY
#define UNWRAP_STRUCT_CAPTURE_ONLY(StructType, StructName, ...) \
case StructType: \
CopyNextChainedStruct(sizeof(StructName), tempMem, nextInput, nextChainTail); \
break;
nextChainTail->pNext = NULL;
while(nextInput)
{
switch(nextInput->sType)
{
PROCESS_SIMPLE_STRUCTS();
// complex structs to handle - require multiple allocations
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_DEPENDENCY_INFO_KHR:
CopyNextChainedStruct(sizeof(VkDependencyInfoKHR), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:
CopyNextChainedStruct(sizeof(VkDescriptorSetAllocateInfo), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:
CopyNextChainedStruct(sizeof(VkDescriptorSetLayoutCreateInfo), tempMem, nextInput,
nextChainTail);
break;
case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR:
CopyNextChainedStruct(sizeof(VkDeviceBufferMemoryRequirementsKHR), tempMem, nextInput,
nextChainTail);
break;
case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
CopyNextChainedStruct(sizeof(VkDeviceGroupDeviceCreateInfo), tempMem, nextInput,
nextChainTail);
break;
case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR:
CopyNextChainedStruct(sizeof(VkDeviceImageMemoryRequirementsKHR), tempMem, nextInput,
nextChainTail);
break;
case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:
CopyNextChainedStruct(sizeof(VkFramebufferCreateInfo), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
CopyNextChainedStruct(sizeof(VkFramebufferAttachmentsCreateInfo), tempMem, nextInput,
nextChainTail);
break;
case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO:
CopyNextChainedStruct(sizeof(VkFramebufferAttachmentImageInfo), tempMem, nextInput,
nextChainTail);
break;
case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
CopyNextChainedStruct(sizeof(VkGraphicsPipelineCreateInfo), tempMem, nextInput,
nextChainTail);
break;
case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
CopyNextChainedStruct(sizeof(VkComputePipelineCreateInfo), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
CopyNextChainedStruct(sizeof(VkPipelineLayoutCreateInfo), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:
CopyNextChainedStruct(sizeof(VkPresentInfoKHR), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO:
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;
case VK_STRUCTURE_TYPE_SUBMIT_INFO:
CopyNextChainedStruct(sizeof(VkSubmitInfo), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR:
CopyNextChainedStruct(sizeof(VkSubmitInfo2KHR), tempMem, nextInput, nextChainTail);
break;
case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
CopyNextChainedStruct(sizeof(VkWriteDescriptorSet), tempMem, nextInput, nextChainTail);
break;
// Android External Buffer Memory Extension
#if ENABLED(RDOC_ANDROID)
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
VkImportAndroidHardwareBufferInfoANDROID);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID,
VkAndroidHardwareBufferUsageANDROID);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID, VkExternalFormatANDROID);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
VkAndroidHardwareBufferFormatPropertiesANDROID);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
VkAndroidHardwareBufferPropertiesANDROID);
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
VkMemoryGetAndroidHardwareBufferInfoANDROID,
UnwrapInPlace(out->memory));
#else
case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID:
{
RDCERR("Support for android external memory buffer extension not compiled in");
break;
}
#endif
#if ENABLED(RDOC_GGP)
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP, VkPresentFrameTokenGGP);
#else
case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
{
RDCERR("Support for GGP frame token extension not compiled in");
break;
}
#endif
// NV win32 external memory extensions
#if ENABLED(RDOC_WIN32)
// Structs that can be copied into place
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
VkImportMemoryWin32HandleInfoNV);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
VkExportMemoryWin32HandleInfoNV);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
VkImportMemoryWin32HandleInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
VkExportMemoryWin32HandleInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR,
VkMemoryWin32HandlePropertiesKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
VkExportSemaphoreWin32HandleInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR,
VkD3D12FenceSubmitInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR,
VkExportFenceWin32HandleInfoKHR);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT,
VkSurfaceFullScreenExclusiveWin32InfoEXT);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT,
VkSurfaceCapabilitiesFullScreenExclusiveEXT);
COPY_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT,
VkSurfaceFullScreenExclusiveInfoEXT);
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR,
VkMemoryGetWin32HandleInfoKHR, UnwrapInPlace(out->memory));
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
VkImportSemaphoreWin32HandleInfoKHR,
UnwrapInPlace(out->semaphore));
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
VkSemaphoreGetWin32HandleInfoKHR, UnwrapInPlace(out->semaphore));
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR,
VkImportFenceWin32HandleInfoKHR, UnwrapInPlace(out->fence));
UNWRAP_STRUCT_CAPTURE_ONLY(VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR,
VkFenceGetWin32HandleInfoKHR, UnwrapInPlace(out->fence));
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
CopyNextChainedStruct(sizeof(VkWin32KeyedMutexAcquireReleaseInfoKHR), tempMem, nextInput,
nextChainTail);
break;
#else
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:
case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
{
RDCERR("Support for win32 external memory extensions not compiled in");
nextChainTail->pNext = nextInput;
break;
}
#endif
case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:
case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:
case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT:
case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT:
case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT:
{
// could be implemented but would need extra work or doesn't make sense right now
RDCERR("Struct %s not handled in %s pNext chain", ToStr(nextInput->sType).c_str(),
structName);
nextChainTail->pNext = nextInput;
break;
}
UNHANDLED_STRUCTS()
{
RDCERR("Unhandled struct %s in %s pNext chain", ToStr(nextInput->sType).c_str(),
structName);
nextChainTail->pNext = nextInput;
break;
}
case VK_STRUCTURE_TYPE_MAX_ENUM:
{
RDCERR("Invalid value %x in %s pNext chain", nextInput->sType, structName);
nextChainTail->pNext = nextInput;
break;
}
}
nextInput = nextInput->pNext;
}
}
Reference in New Issue View Git Blame Copy Permalink