[PATCH 0/6] MR8901: winevulkan: Simplify struct conversion and struct extension enumerations.

List overview All Threads

newer

older

[PATCH v2 0/5] MR8901: winevulkan:...

Re: [PATCH v3 0/2] MR8894:...

Rémi Bernon (＠rbernon)

4 Sep 2025 4 Sep '25

9:37 a.m.

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/8901

Show replies by date

Rémi Bernon

4 Sep 4 Sep

9:37 a.m.

New subject: [PATCH 1/6] winevulkan: Order the win32 structs as other structs.

From: Rémi Bernon rbernon@codeweavers.com

--- dlls/winevulkan/make_vulkan | 6 +- dlls/winevulkan/vulkan_thunks.c | 11682 +++++++++++++++--------------- 2 files changed, 5846 insertions(+), 5842 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 09d450bba71..9be7ef8ca66 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -2614,7 +2614,11 @@ class VkGenerator(object):

f.write("WINE_DEFAULT_DEBUG_CHANNEL(vulkan);\n\n")

- for struct in self.win32_structs: + def unique(list, key=lambda x: x, seen=set()): + return (e for e in list if not (key(e) in seen or seen.add(key(e)))) + + win32_structs = sorted(self.win32_structs, key=lambda struct: (-struct.order, struct.name)) + for struct in unique(win32_structs, key=lambda struct: struct.name): f.write(struct.definition(conv=True, align=True)) f.write("\n")

diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index 3d8882c8db0..dfd1d57e7d6 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -27,470 +27,679 @@

WINE_DEFAULT_DEBUG_CHANNEL(vulkan);

-typedef struct VkAcquireNextImageInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; - uint64_t DECLSPEC_ALIGN(8) timeout; - VkSemaphore DECLSPEC_ALIGN(8) semaphore; - VkFence DECLSPEC_ALIGN(8) fence; - uint32_t deviceMask; -} VkAcquireNextImageInfoKHR32; - -typedef struct VkPerformanceConfigurationAcquireInfoINTEL32 -{ - VkStructureType sType; - PTR32 pNext; - VkPerformanceConfigurationTypeINTEL type; -} VkPerformanceConfigurationAcquireInfoINTEL32; - -typedef struct VkAcquireProfilingLockInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - VkAcquireProfilingLockFlagsKHR flags; - uint64_t DECLSPEC_ALIGN(8) timeout; -} VkAcquireProfilingLockInfoKHR32; - -typedef struct VkCommandBufferAllocateInfo32 -{ - VkStructureType sType; - PTR32 pNext; - VkCommandPool DECLSPEC_ALIGN(8) commandPool; - VkCommandBufferLevel level; - uint32_t commandBufferCount; -} VkCommandBufferAllocateInfo32; - -typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo32 -{ - VkStructureType sType; - PTR32 pNext; - uint32_t descriptorSetCount; - PTR32 pDescriptorCounts; -} VkDescriptorSetVariableDescriptorCountAllocateInfo32; -typedef VkDescriptorSetVariableDescriptorCountAllocateInfo32 VkDescriptorSetVariableDescriptorCountAllocateInfoEXT32; - -typedef struct VkDescriptorSetAllocateInfo32 -{ - VkStructureType sType; - PTR32 pNext; - VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool; - uint32_t descriptorSetCount; - PTR32 pSetLayouts; -} VkDescriptorSetAllocateInfo32; - -typedef struct VkDedicatedAllocationMemoryAllocateInfoNV32 -{ - VkStructureType sType; - PTR32 pNext; - VkImage DECLSPEC_ALIGN(8) image; - VkBuffer DECLSPEC_ALIGN(8) buffer; -} VkDedicatedAllocationMemoryAllocateInfoNV32; - -typedef struct VkExportMemoryAllocateInfo32 -{ - VkStructureType sType; - PTR32 pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExportMemoryAllocateInfo32; -typedef VkExportMemoryAllocateInfo32 VkExportMemoryAllocateInfoKHR32; - -typedef struct VkImportMemoryWin32HandleInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; -} VkImportMemoryWin32HandleInfoKHR32; - -typedef struct VkExportMemoryWin32HandleInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - PTR32 pAttributes; - DWORD dwAccess; - LPCWSTR name; -} VkExportMemoryWin32HandleInfoKHR32; - -typedef struct VkMemoryAllocateFlagsInfo32 -{ - VkStructureType sType; - PTR32 pNext; - VkMemoryAllocateFlags flags; - uint32_t deviceMask; -} VkMemoryAllocateFlagsInfo32; -typedef VkMemoryAllocateFlagsInfo32 VkMemoryAllocateFlagsInfoKHR32; - -typedef struct VkMemoryDedicatedAllocateInfo32 -{ - VkStructureType sType; - PTR32 pNext; - VkImage DECLSPEC_ALIGN(8) image; - VkBuffer DECLSPEC_ALIGN(8) buffer; -} VkMemoryDedicatedAllocateInfo32; -typedef VkMemoryDedicatedAllocateInfo32 VkMemoryDedicatedAllocateInfoKHR32; - -typedef struct VkImportMemoryHostPointerInfoEXT32 +typedef struct VkGeometryAABBNV32 { VkStructureType sType; PTR32 pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - PTR32 pHostPointer; -} VkImportMemoryHostPointerInfoEXT32; + VkBuffer DECLSPEC_ALIGN(8) aabbData; + uint32_t numAABBs; + uint32_t stride; + VkDeviceSize DECLSPEC_ALIGN(8) offset; +} VkGeometryAABBNV32;

-typedef struct VkMemoryPriorityAllocateInfoEXT32 +typedef struct VkGeometryTrianglesNV32 { VkStructureType sType; PTR32 pNext; - float priority; -} VkMemoryPriorityAllocateInfoEXT32; + VkBuffer DECLSPEC_ALIGN(8) vertexData; + VkDeviceSize DECLSPEC_ALIGN(8) vertexOffset; + uint32_t vertexCount; + VkDeviceSize DECLSPEC_ALIGN(8) vertexStride; + VkFormat vertexFormat; + VkBuffer DECLSPEC_ALIGN(8) indexData; + VkDeviceSize DECLSPEC_ALIGN(8) indexOffset; + uint32_t indexCount; + VkIndexType indexType; + VkBuffer DECLSPEC_ALIGN(8) transformData; + VkDeviceSize DECLSPEC_ALIGN(8) transformOffset; +} VkGeometryTrianglesNV32;

-typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo32 +typedef struct VkSpecializationMapEntry32 { - VkStructureType sType; - PTR32 pNext; - uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress; -} VkMemoryOpaqueCaptureAddressAllocateInfo32; -typedef VkMemoryOpaqueCaptureAddressAllocateInfo32 VkMemoryOpaqueCaptureAddressAllocateInfoKHR32; + uint32_t constantID; + uint32_t offset; + PTR32 size; +} VkSpecializationMapEntry32;

-typedef struct VkMemoryDedicatedAllocateInfoTensorARM32 +typedef struct StdVideoH264SequenceParameterSetVui32 { - VkStructureType sType; - PTR32 pNext; - VkTensorARM DECLSPEC_ALIGN(8) tensor; -} VkMemoryDedicatedAllocateInfoTensorARM32; + StdVideoH264SpsVuiFlags flags; + StdVideoH264AspectRatioIdc aspect_ratio_idc; + uint16_t sar_width; + uint16_t sar_height; + uint8_t video_format; + uint8_t colour_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coefficients; + uint32_t num_units_in_tick; + uint32_t time_scale; + uint8_t max_num_reorder_frames; + uint8_t max_dec_frame_buffering; + uint8_t chroma_sample_loc_type_top_field; + uint8_t chroma_sample_loc_type_bottom_field; + uint32_t reserved1; + PTR32 pHrdParameters; +} StdVideoH264SequenceParameterSetVui32;

-typedef struct VkMemoryAllocateInfo32 +typedef struct VkAccelerationStructureGeometryAabbsDataKHR32 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) allocationSize; - uint32_t memoryTypeIndex; -} VkMemoryAllocateInfo32; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data; + VkDeviceSize DECLSPEC_ALIGN(8) stride; +} VkAccelerationStructureGeometryAabbsDataKHR32;

-typedef struct VkAntiLagPresentationInfoAMD32 +typedef struct VkAccelerationStructureGeometryInstancesDataKHR32 { VkStructureType sType; PTR32 pNext; - VkAntiLagStageAMD stage; - uint64_t DECLSPEC_ALIGN(8) frameIndex; -} VkAntiLagPresentationInfoAMD32; + VkBool32 arrayOfPointers; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data; +} VkAccelerationStructureGeometryInstancesDataKHR32;

-typedef struct VkAntiLagDataAMD32 +typedef struct VkAccelerationStructureGeometryTrianglesDataKHR32 { VkStructureType sType; PTR32 pNext; - VkAntiLagModeAMD mode; - uint32_t maxFPS; - PTR32 pPresentationInfo; -} VkAntiLagDataAMD32; + VkFormat vertexFormat; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData; + VkDeviceSize DECLSPEC_ALIGN(8) vertexStride; + uint32_t maxVertex; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) transformData; +} VkAccelerationStructureGeometryTrianglesDataKHR32;

-typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT32 +typedef struct VkClusterAccelerationStructureClustersBottomLevelInputNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 conditionalRenderingEnable; -} VkCommandBufferInheritanceConditionalRenderingInfoEXT32; + uint32_t maxTotalClusterCount; + uint32_t maxClusterCountPerAccelerationStructure; +} VkClusterAccelerationStructureClustersBottomLevelInputNV32;

-typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM32 +typedef struct VkClusterAccelerationStructureMoveObjectsInputNV32 { VkStructureType sType; PTR32 pNext; - VkSurfaceTransformFlagBitsKHR transform; - VkRect2D renderArea; -} VkCommandBufferInheritanceRenderPassTransformInfoQCOM32; + VkClusterAccelerationStructureTypeNV type; + VkBool32 noMoveOverlap; + VkDeviceSize DECLSPEC_ALIGN(8) maxMovedBytes; +} VkClusterAccelerationStructureMoveObjectsInputNV32;

-typedef struct VkCommandBufferInheritanceViewportScissorInfoNV32 +typedef struct VkClusterAccelerationStructureTriangleClusterInputNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 viewportScissor2D; - uint32_t viewportDepthCount; - PTR32 pViewportDepths; -} VkCommandBufferInheritanceViewportScissorInfoNV32; + VkFormat vertexFormat; + uint32_t maxGeometryIndexValue; + uint32_t maxClusterUniqueGeometryCount; + uint32_t maxClusterTriangleCount; + uint32_t maxClusterVertexCount; + uint32_t maxTotalTriangleCount; + uint32_t maxTotalVertexCount; + uint32_t minPositionTruncateBitCount; +} VkClusterAccelerationStructureTriangleClusterInputNV32;

-typedef struct VkCommandBufferInheritanceRenderingInfo32 +typedef struct VkGeometryDataNV32 { - VkStructureType sType; - PTR32 pNext; - VkRenderingFlags flags; - uint32_t viewMask; - uint32_t colorAttachmentCount; - PTR32 pColorAttachmentFormats; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; - VkSampleCountFlagBits rasterizationSamples; -} VkCommandBufferInheritanceRenderingInfo32; -typedef VkCommandBufferInheritanceRenderingInfo32 VkCommandBufferInheritanceRenderingInfoKHR32; + VkGeometryTrianglesNV32 DECLSPEC_ALIGN(8) triangles; + VkGeometryAABBNV32 DECLSPEC_ALIGN(8) aabbs; +} VkGeometryDataNV32;

-typedef struct VkAttachmentSampleCountInfoAMD32 +typedef struct VkIndirectExecutionSetShaderLayoutInfoEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t colorAttachmentCount; - PTR32 pColorAttachmentSamples; - VkSampleCountFlagBits depthStencilAttachmentSamples; -} VkAttachmentSampleCountInfoAMD32; -typedef VkAttachmentSampleCountInfoAMD32 VkAttachmentSampleCountInfoNV32; + uint32_t setLayoutCount; + PTR32 pSetLayouts; +} VkIndirectExecutionSetShaderLayoutInfoEXT32;

-typedef struct VkTileMemoryBindInfoQCOM32 +typedef struct VkPhysicalDeviceLimits32 { - VkStructureType sType; - PTR32 pNext; - VkDeviceMemory DECLSPEC_ALIGN(8) memory; -} VkTileMemoryBindInfoQCOM32; + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferElements; + uint32_t maxUniformBufferRange; + uint32_t maxStorageBufferRange; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + uint32_t maxSamplerAllocationCount; + VkDeviceSize DECLSPEC_ALIGN(8) bufferImageGranularity; + VkDeviceSize DECLSPEC_ALIGN(8) sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxPerStageDescriptorInputAttachments; + uint32_t maxPerStageResources; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxDescriptorSetInputAttachments; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessellationGenerationLevel; + uint32_t maxTessellationPatchSize; + uint32_t maxTessellationControlPerVertexInputComponents; + uint32_t maxTessellationControlPerVertexOutputComponents; + uint32_t maxTessellationControlPerPatchOutputComponents; + uint32_t maxTessellationControlTotalOutputComponents; + uint32_t maxTessellationEvaluationInputComponents; + uint32_t maxTessellationEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputAttachments; + uint32_t maxFragmentDualSrcAttachments; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + PTR32 minMemoryMapAlignment; + VkDeviceSize DECLSPEC_ALIGN(8) minTexelBufferOffsetAlignment; + VkDeviceSize DECLSPEC_ALIGN(8) minUniformBufferOffsetAlignment; + VkDeviceSize DECLSPEC_ALIGN(8) minStorageBufferOffsetAlignment; + int32_t minTexelOffset; + uint32_t maxTexelOffset; + int32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint32_t maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint32_t maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + uint32_t discreteQueuePriorities; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyOffsetAlignment; + VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyRowPitchAlignment; + VkDeviceSize DECLSPEC_ALIGN(8) nonCoherentAtomSize; +} VkPhysicalDeviceLimits32;

-typedef struct VkRenderingAttachmentLocationInfo32 +typedef struct VkSpecializationInfo32 { - VkStructureType sType; - PTR32 pNext; - uint32_t colorAttachmentCount; - PTR32 pColorAttachmentLocations; -} VkRenderingAttachmentLocationInfo32; -typedef VkRenderingAttachmentLocationInfo32 VkRenderingAttachmentLocationInfoKHR32; + uint32_t mapEntryCount; + PTR32 pMapEntries; + PTR32 dataSize; + PTR32 pData; +} VkSpecializationInfo32;

-typedef struct VkRenderingInputAttachmentIndexInfo32 +typedef struct StdVideoAV1TileInfo32 { - VkStructureType sType; - PTR32 pNext; - uint32_t colorAttachmentCount; - PTR32 pColorAttachmentInputIndices; - PTR32 pDepthInputAttachmentIndex; - PTR32 pStencilInputAttachmentIndex; -} VkRenderingInputAttachmentIndexInfo32; -typedef VkRenderingInputAttachmentIndexInfo32 VkRenderingInputAttachmentIndexInfoKHR32; + StdVideoAV1TileInfoFlags flags; + uint8_t TileCols; + uint8_t TileRows; + uint16_t context_update_tile_id; + uint8_t tile_size_bytes_minus_1; + uint8_t reserved1[7]; + PTR32 pMiColStarts; + PTR32 pMiRowStarts; + PTR32 pWidthInSbsMinus1; + PTR32 pHeightInSbsMinus1; +} StdVideoAV1TileInfo32;

-typedef struct VkRenderPassTileShadingCreateInfoQCOM32 +typedef struct StdVideoEncodeH264ReferenceListsInfo32 { - VkStructureType sType; - PTR32 pNext; - VkTileShadingRenderPassFlagsQCOM flags; - VkExtent2D tileApronSize; -} VkRenderPassTileShadingCreateInfoQCOM32; + StdVideoEncodeH264ReferenceListsInfoFlags flags; + uint8_t num_ref_idx_l0_active_minus1; + uint8_t num_ref_idx_l1_active_minus1; + uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; + uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; + uint8_t refList0ModOpCount; + uint8_t refList1ModOpCount; + uint8_t refPicMarkingOpCount; + uint8_t reserved1[7]; + PTR32 pRefList0ModOperations; + PTR32 pRefList1ModOperations; + PTR32 pRefPicMarkingOperations; +} StdVideoEncodeH264ReferenceListsInfo32;

-typedef struct VkCommandBufferInheritanceInfo32 +typedef struct StdVideoEncodeH264SliceHeader32 { - VkStructureType sType; - PTR32 pNext; - VkRenderPass DECLSPEC_ALIGN(8) renderPass; - uint32_t subpass; - VkFramebuffer DECLSPEC_ALIGN(8) framebuffer; - VkBool32 occlusionQueryEnable; - VkQueryControlFlags queryFlags; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkCommandBufferInheritanceInfo32; + StdVideoEncodeH264SliceHeaderFlags flags; + uint32_t first_mb_in_slice; + StdVideoH264SliceType slice_type; + int8_t slice_alpha_c0_offset_div2; + int8_t slice_beta_offset_div2; + int8_t slice_qp_delta; + uint8_t reserved1; + StdVideoH264CabacInitIdc cabac_init_idc; + StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc; + PTR32 pWeightTable; +} StdVideoEncodeH264SliceHeader32;

-typedef struct VkDeviceGroupCommandBufferBeginInfo32 +typedef struct StdVideoH264PictureParameterSet32 +{ + StdVideoH264PpsFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint8_t num_ref_idx_l0_default_active_minus1; + uint8_t num_ref_idx_l1_default_active_minus1; + StdVideoH264WeightedBipredIdc weighted_bipred_idc; + int8_t pic_init_qp_minus26; + int8_t pic_init_qs_minus26; + int8_t chroma_qp_index_offset; + int8_t second_chroma_qp_index_offset; + PTR32 pScalingLists; +} StdVideoH264PictureParameterSet32; + +typedef struct StdVideoH264SequenceParameterSet32 +{ + StdVideoH264SpsFlags flags; + StdVideoH264ProfileIdc profile_idc; + StdVideoH264LevelIdc level_idc; + StdVideoH264ChromaFormatIdc chroma_format_idc; + uint8_t seq_parameter_set_id; + uint8_t bit_depth_luma_minus8; + uint8_t bit_depth_chroma_minus8; + uint8_t log2_max_frame_num_minus4; + StdVideoH264PocType pic_order_cnt_type; + int32_t offset_for_non_ref_pic; + int32_t offset_for_top_to_bottom_field; + uint8_t log2_max_pic_order_cnt_lsb_minus4; + uint8_t num_ref_frames_in_pic_order_cnt_cycle; + uint8_t max_num_ref_frames; + uint8_t reserved1; + uint32_t pic_width_in_mbs_minus1; + uint32_t pic_height_in_map_units_minus1; + uint32_t frame_crop_left_offset; + uint32_t frame_crop_right_offset; + uint32_t frame_crop_top_offset; + uint32_t frame_crop_bottom_offset; + uint32_t reserved2; + PTR32 pOffsetForRefFrame; + PTR32 pScalingLists; + PTR32 pSequenceParameterSetVui; +} StdVideoH264SequenceParameterSet32; + +typedef union VkAccelerationStructureGeometryDataKHR32 +{ + VkAccelerationStructureGeometryTrianglesDataKHR32 DECLSPEC_ALIGN(8) triangles; + VkAccelerationStructureGeometryAabbsDataKHR32 DECLSPEC_ALIGN(8) aabbs; + VkAccelerationStructureGeometryInstancesDataKHR32 DECLSPEC_ALIGN(8) instances; +} VkAccelerationStructureGeometryDataKHR32; + +typedef struct VkAttachmentReference232 { VkStructureType sType; PTR32 pNext; - uint32_t deviceMask; -} VkDeviceGroupCommandBufferBeginInfo32; -typedef VkDeviceGroupCommandBufferBeginInfo32 VkDeviceGroupCommandBufferBeginInfoKHR32; + uint32_t attachment; + VkImageLayout layout; + VkImageAspectFlags aspectMask; +} VkAttachmentReference232; +typedef VkAttachmentReference232 VkAttachmentReference2KHR32;

-typedef struct VkCommandBufferBeginInfo32 +typedef union VkClusterAccelerationStructureOpInputNV32 +{ + PTR32 pClustersBottomLevel; + PTR32 pTriangleClusters; + PTR32 pMoveObjects; +} VkClusterAccelerationStructureOpInputNV32; + +typedef struct VkDescriptorAddressInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkCommandBufferUsageFlags flags; - PTR32 pInheritanceInfo; -} VkCommandBufferBeginInfo32; + VkDeviceAddress DECLSPEC_ALIGN(8) address; + VkDeviceSize DECLSPEC_ALIGN(8) range; + VkFormat format; +} VkDescriptorAddressInfoEXT32;

-typedef struct VkBindAccelerationStructureMemoryInfoNV32 +typedef struct VkDescriptorBufferInfo32 +{ + VkBuffer DECLSPEC_ALIGN(8) buffer; + VkDeviceSize DECLSPEC_ALIGN(8) offset; + VkDeviceSize DECLSPEC_ALIGN(8) range; +} VkDescriptorBufferInfo32; + +typedef struct VkDescriptorImageInfo32 +{ + VkSampler DECLSPEC_ALIGN(8) sampler; + VkImageView DECLSPEC_ALIGN(8) imageView; + VkImageLayout imageLayout; +} VkDescriptorImageInfo32; + +typedef struct VkGeometryNV32 { VkStructureType sType; PTR32 pNext; - VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure; - VkDeviceMemory DECLSPEC_ALIGN(8) memory; - VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; - uint32_t deviceIndexCount; - PTR32 pDeviceIndices; -} VkBindAccelerationStructureMemoryInfoNV32; + VkGeometryTypeKHR geometryType; + VkGeometryDataNV32 DECLSPEC_ALIGN(8) geometry; + VkGeometryFlagsKHR flags; +} VkGeometryNV32;

-typedef struct VkBindBufferMemoryDeviceGroupInfo32 +typedef struct VkImageCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t deviceIndexCount; - PTR32 pDeviceIndices; -} VkBindBufferMemoryDeviceGroupInfo32; -typedef VkBindBufferMemoryDeviceGroupInfo32 VkBindBufferMemoryDeviceGroupInfoKHR32; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + PTR32 pQueueFamilyIndices; + VkImageLayout initialLayout; +} VkImageCreateInfo32;

-typedef struct VkBindMemoryStatus32 +typedef union VkIndirectCommandsTokenDataEXT32 +{ + PTR32 pPushConstant; + PTR32 pVertexBuffer; + PTR32 pIndexBuffer; + PTR32 pExecutionSet; +} VkIndirectCommandsTokenDataEXT32; + +typedef struct VkIndirectExecutionSetPipelineInfoEXT32 { VkStructureType sType; PTR32 pNext; - PTR32 pResult; -} VkBindMemoryStatus32; -typedef VkBindMemoryStatus32 VkBindMemoryStatusKHR32; + VkPipeline DECLSPEC_ALIGN(8) initialPipeline; + uint32_t maxPipelineCount; +} VkIndirectExecutionSetPipelineInfoEXT32;

-typedef struct VkBindBufferMemoryInfo32 +typedef struct VkIndirectExecutionSetShaderInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBuffer DECLSPEC_ALIGN(8) buffer; - VkDeviceMemory DECLSPEC_ALIGN(8) memory; - VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; -} VkBindBufferMemoryInfo32; -typedef VkBindBufferMemoryInfo32 VkBindBufferMemoryInfoKHR32; + uint32_t shaderCount; + PTR32 pInitialShaders; + PTR32 pSetLayoutInfos; + uint32_t maxShaderCount; + uint32_t pushConstantRangeCount; + PTR32 pPushConstantRanges; +} VkIndirectExecutionSetShaderInfoEXT32;

-typedef struct VkBindDataGraphPipelineSessionMemoryInfoARM32 +typedef struct VkMemoryHeap32 +{ + VkDeviceSize DECLSPEC_ALIGN(8) size; + VkMemoryHeapFlags flags; +} VkMemoryHeap32; + +typedef struct VkPhysicalDeviceProperties32 +{ + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + VkPhysicalDeviceType deviceType; + char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; + uint8_t pipelineCacheUUID[VK_UUID_SIZE]; + VkPhysicalDeviceLimits32 DECLSPEC_ALIGN(8) limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} VkPhysicalDeviceProperties32; + +typedef struct VkPipelineBinaryDataKHR32 +{ + PTR32 dataSize; + PTR32 pData; +} VkPipelineBinaryDataKHR32; + +typedef struct VkPipelineBinaryKeyKHR32 { VkStructureType sType; PTR32 pNext; - VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session; - VkDataGraphPipelineSessionBindPointARM bindPoint; - uint32_t objectIndex; - VkDeviceMemory DECLSPEC_ALIGN(8) memory; - VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; -} VkBindDataGraphPipelineSessionMemoryInfoARM32; + uint32_t keySize; + uint8_t key[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR]; +} VkPipelineBinaryKeyKHR32;

-typedef struct VkBindImageMemoryDeviceGroupInfo32 +typedef struct VkPipelineShaderStageCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t deviceIndexCount; - PTR32 pDeviceIndices; - uint32_t splitInstanceBindRegionCount; - PTR32 pSplitInstanceBindRegions; -} VkBindImageMemoryDeviceGroupInfo32; -typedef VkBindImageMemoryDeviceGroupInfo32 VkBindImageMemoryDeviceGroupInfoKHR32; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule DECLSPEC_ALIGN(8) module; + PTR32 pName; + PTR32 pSpecializationInfo; +} VkPipelineShaderStageCreateInfo32;

-typedef struct VkBindImageMemorySwapchainInfoKHR32 +typedef struct VkPipelineTessellationStateCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; - uint32_t imageIndex; -} VkBindImageMemorySwapchainInfoKHR32; + VkPipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; +} VkPipelineTessellationStateCreateInfo32;

-typedef struct VkBindImagePlaneMemoryInfo32 +typedef struct VkPipelineVertexInputStateCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkImageAspectFlagBits planeAspect; -} VkBindImagePlaneMemoryInfo32; -typedef VkBindImagePlaneMemoryInfo32 VkBindImagePlaneMemoryInfoKHR32; + VkPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + PTR32 pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + PTR32 pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo32;

-typedef struct VkBindImageMemoryInfo32 +typedef struct VkSampleLocationsInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkImage DECLSPEC_ALIGN(8) image; - VkDeviceMemory DECLSPEC_ALIGN(8) memory; - VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; -} VkBindImageMemoryInfo32; -typedef VkBindImageMemoryInfo32 VkBindImageMemoryInfoKHR32; + VkSampleCountFlagBits sampleLocationsPerPixel; + VkExtent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + PTR32 pSampleLocations; +} VkSampleLocationsInfoEXT32;

-typedef struct VkBindTensorMemoryInfoARM32 +typedef struct VkSparseImageMemoryBind32 { - VkStructureType sType; - PTR32 pNext; - VkTensorARM DECLSPEC_ALIGN(8) tensor; + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; VkDeviceMemory DECLSPEC_ALIGN(8) memory; VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; -} VkBindTensorMemoryInfoARM32; + VkSparseMemoryBindFlags flags; +} VkSparseImageMemoryBind32;

-typedef struct VkBindVideoSessionMemoryInfoKHR32 +typedef struct VkSparseMemoryBind32 { - VkStructureType sType; - PTR32 pNext; - uint32_t memoryBindIndex; + VkDeviceSize DECLSPEC_ALIGN(8) resourceOffset; + VkDeviceSize DECLSPEC_ALIGN(8) size; VkDeviceMemory DECLSPEC_ALIGN(8) memory; VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; - VkDeviceSize DECLSPEC_ALIGN(8) memorySize; -} VkBindVideoSessionMemoryInfoKHR32; + VkSparseMemoryBindFlags flags; +} VkSparseMemoryBind32;

-typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV32 +typedef struct VkTensorDescriptionARM32 { VkStructureType sType; PTR32 pNext; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData; -} VkAccelerationStructureGeometryMotionTrianglesDataNV32; + VkTensorTilingARM tiling; + VkFormat format; + uint32_t dimensionCount; + PTR32 pDimensions; + PTR32 pStrides; + VkTensorUsageFlagsARM DECLSPEC_ALIGN(8) usage; +} VkTensorDescriptionARM32;

-typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT32 +typedef struct VkVideoPictureResourceInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkIndexType indexType; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexBuffer; - VkDeviceSize DECLSPEC_ALIGN(8) indexStride; - uint32_t baseTriangle; - uint32_t usageCountsCount; - PTR32 pUsageCounts; - PTR32 ppUsageCounts; - VkMicromapEXT DECLSPEC_ALIGN(8) micromap; -} VkAccelerationStructureTrianglesOpacityMicromapEXT32; + VkOffset2D codedOffset; + VkExtent2D codedExtent; + uint32_t baseArrayLayer; + VkImageView DECLSPEC_ALIGN(8) imageViewBinding; +} VkVideoPictureResourceInfoKHR32;

-typedef struct VkAccelerationStructureGeometryTrianglesDataKHR32 +typedef struct StdVideoAV1SequenceHeader32 { - VkStructureType sType; - PTR32 pNext; - VkFormat vertexFormat; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData; - VkDeviceSize DECLSPEC_ALIGN(8) vertexStride; - uint32_t maxVertex; - VkIndexType indexType; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) transformData; -} VkAccelerationStructureGeometryTrianglesDataKHR32; + StdVideoAV1SequenceHeaderFlags flags; + StdVideoAV1Profile seq_profile; + uint8_t frame_width_bits_minus_1; + uint8_t frame_height_bits_minus_1; + uint16_t max_frame_width_minus_1; + uint16_t max_frame_height_minus_1; + uint8_t delta_frame_id_length_minus_2; + uint8_t additional_frame_id_length_minus_1; + uint8_t order_hint_bits_minus_1; + uint8_t seq_force_integer_mv; + uint8_t seq_force_screen_content_tools; + uint8_t reserved1[5]; + PTR32 pColorConfig; + PTR32 pTimingInfo; +} StdVideoAV1SequenceHeader32;

-typedef struct VkAccelerationStructureGeometryAabbsDataKHR32 +typedef struct StdVideoDecodeAV1PictureInfo32 { - VkStructureType sType; - PTR32 pNext; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data; - VkDeviceSize DECLSPEC_ALIGN(8) stride; -} VkAccelerationStructureGeometryAabbsDataKHR32; + StdVideoDecodeAV1PictureInfoFlags flags; + StdVideoAV1FrameType frame_type; + uint32_t current_frame_id; + uint8_t OrderHint; + uint8_t primary_ref_frame; + uint8_t refresh_frame_flags; + uint8_t reserved1; + StdVideoAV1InterpolationFilter interpolation_filter; + StdVideoAV1TxMode TxMode; + uint8_t delta_q_res; + uint8_t delta_lf_res; + uint8_t SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES]; + uint8_t coded_denom; + uint8_t reserved2[3]; + uint8_t OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; + uint32_t expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES]; + PTR32 pTileInfo; + PTR32 pQuantization; + PTR32 pSegmentation; + PTR32 pLoopFilter; + PTR32 pCDEF; + PTR32 pLoopRestoration; + PTR32 pGlobalMotion; + PTR32 pFilmGrain; +} StdVideoDecodeAV1PictureInfo32;

-typedef struct VkAccelerationStructureGeometryInstancesDataKHR32 +typedef struct StdVideoDecodeVP9PictureInfo32 { - VkStructureType sType; - PTR32 pNext; - VkBool32 arrayOfPointers; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data; -} VkAccelerationStructureGeometryInstancesDataKHR32; + StdVideoDecodeVP9PictureInfoFlags flags; + StdVideoVP9Profile profile; + StdVideoVP9FrameType frame_type; + uint8_t frame_context_idx; + uint8_t reset_frame_context; + uint8_t refresh_frame_flags; + uint8_t ref_frame_sign_bias_mask; + StdVideoVP9InterpolationFilter interpolation_filter; + uint8_t base_q_idx; + int8_t delta_q_y_dc; + int8_t delta_q_uv_dc; + int8_t delta_q_uv_ac; + uint8_t tile_cols_log2; + uint8_t tile_rows_log2; + uint16_t reserved1[3]; + PTR32 pColorConfig; + PTR32 pLoopFilter; + PTR32 pSegmentation; +} StdVideoDecodeVP9PictureInfo32;

-typedef union VkAccelerationStructureGeometryDataKHR32 +typedef struct StdVideoEncodeAV1PictureInfo32 { - VkAccelerationStructureGeometryTrianglesDataKHR32 DECLSPEC_ALIGN(8) triangles; - VkAccelerationStructureGeometryAabbsDataKHR32 DECLSPEC_ALIGN(8) aabbs; - VkAccelerationStructureGeometryInstancesDataKHR32 DECLSPEC_ALIGN(8) instances; -} VkAccelerationStructureGeometryDataKHR32; + StdVideoEncodeAV1PictureInfoFlags flags; + StdVideoAV1FrameType frame_type; + uint32_t frame_presentation_time; + uint32_t current_frame_id; + uint8_t order_hint; + uint8_t primary_ref_frame; + uint8_t refresh_frame_flags; + uint8_t coded_denom; + uint16_t render_width_minus_1; + uint16_t render_height_minus_1; + StdVideoAV1InterpolationFilter interpolation_filter; + StdVideoAV1TxMode TxMode; + uint8_t delta_q_res; + uint8_t delta_lf_res; + uint8_t ref_order_hint[STD_VIDEO_AV1_NUM_REF_FRAMES]; + int8_t ref_frame_idx[STD_VIDEO_AV1_REFS_PER_FRAME]; + uint8_t reserved1[3]; + uint32_t delta_frame_id_minus_1[STD_VIDEO_AV1_REFS_PER_FRAME]; + PTR32 pTileInfo; + PTR32 pQuantization; + PTR32 pSegmentation; + PTR32 pLoopFilter; + PTR32 pCDEF; + PTR32 pLoopRestoration; + PTR32 pGlobalMotion; + PTR32 pExtensionHeader; + PTR32 pBufferRemovalTimes; +} StdVideoEncodeAV1PictureInfo32;

-typedef struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV32 +typedef struct StdVideoEncodeAV1ReferenceInfo32 { - VkStructureType sType; - PTR32 pNext; - VkFormat vertexFormat; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData; - VkDeviceSize DECLSPEC_ALIGN(8) vertexStride; - VkFormat radiusFormat; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) radiusData; - VkDeviceSize DECLSPEC_ALIGN(8) radiusStride; - VkIndexType indexType; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData; - VkDeviceSize DECLSPEC_ALIGN(8) indexStride; - VkRayTracingLssIndexingModeNV indexingMode; - VkRayTracingLssPrimitiveEndCapsModeNV endCapsMode; -} VkAccelerationStructureGeometryLinearSweptSpheresDataNV32; + StdVideoEncodeAV1ReferenceInfoFlags flags; + uint32_t RefFrameId; + StdVideoAV1FrameType frame_type; + uint8_t OrderHint; + uint8_t reserved1[3]; + PTR32 pExtensionHeader; +} StdVideoEncodeAV1ReferenceInfo32;

-typedef struct VkAccelerationStructureGeometrySpheresDataNV32 +typedef struct StdVideoEncodeH264PictureInfo32 { - VkStructureType sType; - PTR32 pNext; - VkFormat vertexFormat; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData; - VkDeviceSize DECLSPEC_ALIGN(8) vertexStride; - VkFormat radiusFormat; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) radiusData; - VkDeviceSize DECLSPEC_ALIGN(8) radiusStride; - VkIndexType indexType; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData; - VkDeviceSize DECLSPEC_ALIGN(8) indexStride; -} VkAccelerationStructureGeometrySpheresDataNV32; + StdVideoEncodeH264PictureInfoFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint16_t idr_pic_id; + StdVideoH264PictureType primary_pic_type; + uint32_t frame_num; + int32_t PicOrderCnt; + uint8_t temporal_id; + uint8_t reserved1[3]; + PTR32 pRefLists; +} StdVideoEncodeH264PictureInfo32;

typedef struct VkAccelerationStructureGeometryKHR32 { @@ -501,70 +710,51 @@ typedef struct VkAccelerationStructureGeometryKHR32 VkGeometryFlagsKHR flags; } VkAccelerationStructureGeometryKHR32;

-typedef struct VkAccelerationStructureBuildGeometryInfoKHR32 +typedef struct VkAccelerationStructureInfoNV32 { VkStructureType sType; PTR32 pNext; - VkAccelerationStructureTypeKHR type; - VkBuildAccelerationStructureFlagsKHR flags; - VkBuildAccelerationStructureModeKHR mode; - VkAccelerationStructureKHR DECLSPEC_ALIGN(8) srcAccelerationStructure; - VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dstAccelerationStructure; + VkAccelerationStructureTypeNV type; + VkBuildAccelerationStructureFlagsNV flags; + uint32_t instanceCount; uint32_t geometryCount; PTR32 pGeometries; - PTR32 ppGeometries; - VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData; -} VkAccelerationStructureBuildGeometryInfoKHR32; - -typedef struct VkMicromapBuildInfoEXT32 -{ - VkStructureType sType; - PTR32 pNext; - VkMicromapTypeEXT type; - VkBuildMicromapFlagsEXT flags; - VkBuildMicromapModeEXT mode; - VkMicromapEXT DECLSPEC_ALIGN(8) dstMicromap; - uint32_t usageCountsCount; - PTR32 pUsageCounts; - PTR32 ppUsageCounts; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data; - VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) triangleArray; - VkDeviceSize DECLSPEC_ALIGN(8) triangleArrayStride; -} VkMicromapBuildInfoEXT32; - -typedef struct VkConditionalRenderingBeginInfoEXT32 -{ - VkStructureType sType; - PTR32 pNext; - VkBuffer DECLSPEC_ALIGN(8) buffer; - VkDeviceSize DECLSPEC_ALIGN(8) offset; - VkConditionalRenderingFlagsEXT flags; -} VkConditionalRenderingBeginInfoEXT32; +} VkAccelerationStructureInfoNV32;

-typedef struct VkDebugUtilsLabelEXT32 +typedef struct VkAntiLagPresentationInfoAMD32 { VkStructureType sType; PTR32 pNext; - PTR32 pLabelName; - float color[4]; -} VkDebugUtilsLabelEXT32; + VkAntiLagStageAMD stage; + uint64_t DECLSPEC_ALIGN(8) frameIndex; +} VkAntiLagPresentationInfoAMD32;

-typedef struct VkPerTileBeginInfoQCOM32 +typedef struct VkApplicationInfo32 { VkStructureType sType; PTR32 pNext; -} VkPerTileBeginInfoQCOM32; + PTR32 pApplicationName; + uint32_t applicationVersion; + PTR32 pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo32;

-typedef struct VkSampleLocationsInfoEXT32 +typedef struct VkAttachmentDescription232 { VkStructureType sType; PTR32 pNext; - VkSampleCountFlagBits sampleLocationsPerPixel; - VkExtent2D sampleLocationGridSize; - uint32_t sampleLocationsCount; - PTR32 pSampleLocations; -} VkSampleLocationsInfoEXT32; + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription232; +typedef VkAttachmentDescription232 VkAttachmentDescription2KHR32;

typedef struct VkAttachmentSampleLocationsEXT32 { @@ -572,518 +762,676 @@ typedef struct VkAttachmentSampleLocationsEXT32 VkSampleLocationsInfoEXT32 sampleLocationsInfo; } VkAttachmentSampleLocationsEXT32;

-typedef struct VkSubpassSampleLocationsEXT32 +typedef struct VkBufferCopy232 { - uint32_t subpassIndex; - VkSampleLocationsInfoEXT32 sampleLocationsInfo; -} VkSubpassSampleLocationsEXT32; + VkStructureType sType; + PTR32 pNext; + VkDeviceSize DECLSPEC_ALIGN(8) srcOffset; + VkDeviceSize DECLSPEC_ALIGN(8) dstOffset; + VkDeviceSize DECLSPEC_ALIGN(8) size; +} VkBufferCopy232; +typedef VkBufferCopy232 VkBufferCopy2KHR32;

-typedef struct VkRenderPassStripeInfoARM32 +typedef struct VkBufferCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkRect2D stripeArea; -} VkRenderPassStripeInfoARM32; + VkBufferCreateFlags flags; + VkDeviceSize DECLSPEC_ALIGN(8) size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + PTR32 pQueueFamilyIndices; +} VkBufferCreateInfo32;

-typedef struct VkDeviceGroupRenderPassBeginInfo32 +typedef struct VkBufferImageCopy232 { VkStructureType sType; PTR32 pNext; - uint32_t deviceMask; - uint32_t deviceRenderAreaCount; - PTR32 pDeviceRenderAreas; -} VkDeviceGroupRenderPassBeginInfo32; -typedef VkDeviceGroupRenderPassBeginInfo32 VkDeviceGroupRenderPassBeginInfoKHR32; + VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy232; +typedef VkBufferImageCopy232 VkBufferImageCopy2KHR32;

-typedef struct VkRenderPassSampleLocationsBeginInfoEXT32 +typedef struct VkBufferMemoryBarrier232 { VkStructureType sType; PTR32 pNext; - uint32_t attachmentInitialSampleLocationsCount; - PTR32 pAttachmentInitialSampleLocations; - uint32_t postSubpassSampleLocationsCount; - PTR32 pPostSubpassSampleLocations; -} VkRenderPassSampleLocationsBeginInfoEXT32; + VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask; + VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask; + VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask; + VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer DECLSPEC_ALIGN(8) buffer; + VkDeviceSize DECLSPEC_ALIGN(8) offset; + VkDeviceSize DECLSPEC_ALIGN(8) size; +} VkBufferMemoryBarrier232; +typedef VkBufferMemoryBarrier232 VkBufferMemoryBarrier2KHR32;

-typedef struct VkRenderPassAttachmentBeginInfo32 +typedef struct VkClusterAccelerationStructureInputInfoNV32 { VkStructureType sType; PTR32 pNext; - uint32_t attachmentCount; - PTR32 pAttachments; -} VkRenderPassAttachmentBeginInfo32; -typedef VkRenderPassAttachmentBeginInfo32 VkRenderPassAttachmentBeginInfoKHR32; + uint32_t maxAccelerationStructureCount; + VkBuildAccelerationStructureFlagsKHR flags; + VkClusterAccelerationStructureOpTypeNV opType; + VkClusterAccelerationStructureOpModeNV opMode; + VkClusterAccelerationStructureOpInputNV32 opInput; +} VkClusterAccelerationStructureInputInfoNV32;

-typedef struct VkRenderPassTransformBeginInfoQCOM32 +typedef struct VkCoarseSampleOrderCustomNV32 +{ + VkShadingRatePaletteEntryNV shadingRate; + uint32_t sampleCount; + uint32_t sampleLocationCount; + PTR32 pSampleLocations; +} VkCoarseSampleOrderCustomNV32; + +typedef struct VkCommandBufferInheritanceInfo32 { VkStructureType sType; PTR32 pNext; - VkSurfaceTransformFlagBitsKHR transform; -} VkRenderPassTransformBeginInfoQCOM32; + VkRenderPass DECLSPEC_ALIGN(8) renderPass; + uint32_t subpass; + VkFramebuffer DECLSPEC_ALIGN(8) framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkCommandBufferInheritanceInfo32;

-typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 +typedef struct VkCommandBufferSubmitInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t perViewRenderAreaCount; - PTR32 pPerViewRenderAreas; -} VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32; + PTR32 commandBuffer; + uint32_t deviceMask; +} VkCommandBufferSubmitInfo32; +typedef VkCommandBufferSubmitInfo32 VkCommandBufferSubmitInfoKHR32;

-typedef struct VkRenderPassStripeBeginInfoARM32 +typedef struct VkDataGraphPipelineConstantARM32 { VkStructureType sType; PTR32 pNext; - uint32_t stripeInfoCount; - PTR32 pStripeInfos; -} VkRenderPassStripeBeginInfoARM32; + uint32_t id; + PTR32 pConstantData; +} VkDataGraphPipelineConstantARM32;

-typedef struct VkRenderPassBeginInfo32 +typedef struct VkDataGraphPipelineResourceInfoARM32 { VkStructureType sType; PTR32 pNext; - VkRenderPass DECLSPEC_ALIGN(8) renderPass; - VkFramebuffer DECLSPEC_ALIGN(8) framebuffer; - VkRect2D renderArea; - uint32_t clearValueCount; - PTR32 pClearValues; -} VkRenderPassBeginInfo32; + uint32_t descriptorSet; + uint32_t binding; + uint32_t arrayElement; +} VkDataGraphPipelineResourceInfoARM32;

-typedef struct VkSubpassBeginInfo32 +typedef struct VkDebugUtilsLabelEXT32 { VkStructureType sType; PTR32 pNext; - VkSubpassContents contents; -} VkSubpassBeginInfo32; -typedef VkSubpassBeginInfo32 VkSubpassBeginInfoKHR32; + PTR32 pLabelName; + float color[4]; +} VkDebugUtilsLabelEXT32;

-typedef struct VkAttachmentFeedbackLoopInfoEXT32 +typedef struct VkDebugUtilsObjectNameInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 feedbackLoopEnable; -} VkAttachmentFeedbackLoopInfoEXT32; + VkObjectType objectType; + uint64_t DECLSPEC_ALIGN(8) objectHandle; + PTR32 pObjectName; +} VkDebugUtilsObjectNameInfoEXT32;

-typedef struct VkRenderingAttachmentInfo32 +typedef union VkDescriptorDataEXT32 +{ + PTR32 pSampler; + PTR32 pCombinedImageSampler; + PTR32 pInputAttachmentImage; + PTR32 pSampledImage; + PTR32 pStorageImage; + PTR32 pUniformTexelBuffer; + PTR32 pStorageTexelBuffer; + PTR32 pUniformBuffer; + PTR32 pStorageBuffer; + VkDeviceAddress DECLSPEC_ALIGN(8) accelerationStructure; +} VkDescriptorDataEXT32; + +typedef struct VkDescriptorSetLayoutBinding32 +{ + uint32_t binding; + VkDescriptorType descriptorType; + uint32_t descriptorCount; + VkShaderStageFlags stageFlags; + PTR32 pImmutableSamplers; +} VkDescriptorSetLayoutBinding32; + +typedef struct VkDescriptorUpdateTemplateEntry32 +{ + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + PTR32 offset; + PTR32 stride; +} VkDescriptorUpdateTemplateEntry32; +typedef VkDescriptorUpdateTemplateEntry32 VkDescriptorUpdateTemplateEntryKHR32; + +typedef struct VkDeviceFaultAddressInfoEXT32 +{ + VkDeviceFaultAddressTypeEXT addressType; + VkDeviceAddress DECLSPEC_ALIGN(8) reportedAddress; + VkDeviceSize DECLSPEC_ALIGN(8) addressPrecision; +} VkDeviceFaultAddressInfoEXT32; + +typedef struct VkDeviceFaultVendorInfoEXT32 +{ + char description[VK_MAX_DESCRIPTION_SIZE]; + uint64_t DECLSPEC_ALIGN(8) vendorFaultCode; + uint64_t DECLSPEC_ALIGN(8) vendorFaultData; +} VkDeviceFaultVendorInfoEXT32; + +typedef struct VkDeviceQueueCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkImageView DECLSPEC_ALIGN(8) imageView; - VkImageLayout imageLayout; - VkResolveModeFlagBits resolveMode; - VkImageView DECLSPEC_ALIGN(8) resolveImageView; - VkImageLayout resolveImageLayout; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkClearValue clearValue; -} VkRenderingAttachmentInfo32; -typedef VkRenderingAttachmentInfo32 VkRenderingAttachmentInfoKHR32; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + PTR32 pQueuePriorities; +} VkDeviceQueueCreateInfo32; + +typedef struct VkFramebufferAttachmentImageInfo32 +{ + VkStructureType sType; + PTR32 pNext; + VkImageCreateFlags flags; + VkImageUsageFlags usage; + uint32_t width; + uint32_t height; + uint32_t layerCount; + uint32_t viewFormatCount; + PTR32 pViewFormats; +} VkFramebufferAttachmentImageInfo32; +typedef VkFramebufferAttachmentImageInfo32 VkFramebufferAttachmentImageInfoKHR32; + +typedef struct VkGraphicsShaderGroupCreateInfoNV32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t stageCount; + PTR32 pStages; + PTR32 pVertexInputState; + PTR32 pTessellationState; +} VkGraphicsShaderGroupCreateInfoNV32;

-typedef struct VkMultisampledRenderToSingleSampledInfoEXT32 +typedef struct VkImageBlit232 { VkStructureType sType; PTR32 pNext; - VkBool32 multisampledRenderToSingleSampledEnable; - VkSampleCountFlagBits rasterizationSamples; -} VkMultisampledRenderToSingleSampledInfoEXT32; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit232; +typedef VkImageBlit232 VkImageBlit2KHR32;

-typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR32 +typedef struct VkImageCopy232 { VkStructureType sType; PTR32 pNext; - VkImageView DECLSPEC_ALIGN(8) imageView; - VkImageLayout imageLayout; - VkExtent2D shadingRateAttachmentTexelSize; -} VkRenderingFragmentShadingRateAttachmentInfoKHR32; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy232; +typedef VkImageCopy232 VkImageCopy2KHR32;

-typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT32 +typedef struct VkImageFormatProperties32 +{ + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize DECLSPEC_ALIGN(8) maxResourceSize; +} VkImageFormatProperties32; + +typedef struct VkImageMemoryBarrier232 { VkStructureType sType; PTR32 pNext; - VkImageView DECLSPEC_ALIGN(8) imageView; - VkImageLayout imageLayout; -} VkRenderingFragmentDensityMapAttachmentInfoEXT32; + VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask; + VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask; + VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask; + VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage DECLSPEC_ALIGN(8) image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier232; +typedef VkImageMemoryBarrier232 VkImageMemoryBarrier2KHR32;

-typedef struct VkTileMemorySizeInfoQCOM32 +typedef struct VkImageResolve232 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) size; -} VkTileMemorySizeInfoQCOM32; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve232; +typedef VkImageResolve232 VkImageResolve2KHR32;

-typedef struct VkRenderingInfo32 +typedef struct VkImageSubresource232 { VkStructureType sType; PTR32 pNext; - VkRenderingFlags flags; - VkRect2D renderArea; - uint32_t layerCount; - uint32_t viewMask; - uint32_t colorAttachmentCount; - PTR32 pColorAttachments; - PTR32 pDepthAttachment; - PTR32 pStencilAttachment; -} VkRenderingInfo32; -typedef VkRenderingInfo32 VkRenderingInfoKHR32; + VkImageSubresource imageSubresource; +} VkImageSubresource232; +typedef VkImageSubresource232 VkImageSubresource2KHR32; +typedef VkImageSubresource232 VkImageSubresource2EXT32;

-typedef struct VkVideoEncodeH264RateControlLayerInfoKHR32 +typedef struct VkImageToMemoryCopy32 { VkStructureType sType; PTR32 pNext; - VkBool32 useMinQp; - VkVideoEncodeH264QpKHR minQp; - VkBool32 useMaxQp; - VkVideoEncodeH264QpKHR maxQp; - VkBool32 useMaxFrameSize; - VkVideoEncodeH264FrameSizeKHR maxFrameSize; -} VkVideoEncodeH264RateControlLayerInfoKHR32; + PTR32 pHostPointer; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkImageToMemoryCopy32; +typedef VkImageToMemoryCopy32 VkImageToMemoryCopyEXT32;

-typedef struct VkVideoEncodeAV1RateControlLayerInfoKHR32 +typedef struct VkIndirectCommandsLayoutTokenEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 useMinQIndex; - VkVideoEncodeAV1QIndexKHR minQIndex; - VkBool32 useMaxQIndex; - VkVideoEncodeAV1QIndexKHR maxQIndex; - VkBool32 useMaxFrameSize; - VkVideoEncodeAV1FrameSizeKHR maxFrameSize; -} VkVideoEncodeAV1RateControlLayerInfoKHR32; + VkIndirectCommandsTokenTypeEXT type; + VkIndirectCommandsTokenDataEXT32 data; + uint32_t offset; +} VkIndirectCommandsLayoutTokenEXT32;

-typedef struct VkVideoEncodeRateControlLayerInfoKHR32 +typedef struct VkIndirectCommandsLayoutTokenNV32 { VkStructureType sType; PTR32 pNext; - uint64_t DECLSPEC_ALIGN(8) averageBitrate; - uint64_t DECLSPEC_ALIGN(8) maxBitrate; - uint32_t frameRateNumerator; - uint32_t frameRateDenominator; -} VkVideoEncodeRateControlLayerInfoKHR32; + VkIndirectCommandsTokenTypeNV tokenType; + uint32_t stream; + uint32_t offset; + uint32_t vertexBindingUnit; + VkBool32 vertexDynamicStride; + VkPipelineLayout DECLSPEC_ALIGN(8) pushconstantPipelineLayout; + VkShaderStageFlags pushconstantShaderStageFlags; + uint32_t pushconstantOffset; + uint32_t pushconstantSize; + VkIndirectStateFlagsNV indirectStateFlags; + uint32_t indexTypeCount; + PTR32 pIndexTypes; + PTR32 pIndexTypeValues; +} VkIndirectCommandsLayoutTokenNV32;

-typedef struct StdVideoEncodeAV1ReferenceInfo32 +typedef struct VkIndirectCommandsStreamNV32 { - StdVideoEncodeAV1ReferenceInfoFlags flags; - uint32_t RefFrameId; - StdVideoAV1FrameType frame_type; - uint8_t OrderHint; - uint8_t reserved1[3]; - PTR32 pExtensionHeader; -} StdVideoEncodeAV1ReferenceInfo32; + VkBuffer DECLSPEC_ALIGN(8) buffer; + VkDeviceSize DECLSPEC_ALIGN(8) offset; +} VkIndirectCommandsStreamNV32;

-typedef struct VkVideoPictureResourceInfoKHR32 +typedef union VkIndirectExecutionSetInfoEXT32 { - VkStructureType sType; - PTR32 pNext; - VkOffset2D codedOffset; - VkExtent2D codedExtent; - uint32_t baseArrayLayer; - VkImageView DECLSPEC_ALIGN(8) imageViewBinding; -} VkVideoPictureResourceInfoKHR32; + PTR32 pPipelineInfo; + PTR32 pShaderInfo; +} VkIndirectExecutionSetInfoEXT32;

-typedef struct VkVideoDecodeH264DpbSlotInfoKHR32 +typedef struct VkLatencyTimingsFrameReportNV32 { VkStructureType sType; PTR32 pNext; - PTR32 pStdReferenceInfo; -} VkVideoDecodeH264DpbSlotInfoKHR32; + uint64_t DECLSPEC_ALIGN(8) presentID; + uint64_t DECLSPEC_ALIGN(8) inputSampleTimeUs; + uint64_t DECLSPEC_ALIGN(8) simStartTimeUs; + uint64_t DECLSPEC_ALIGN(8) simEndTimeUs; + uint64_t DECLSPEC_ALIGN(8) renderSubmitStartTimeUs; + uint64_t DECLSPEC_ALIGN(8) renderSubmitEndTimeUs; + uint64_t DECLSPEC_ALIGN(8) presentStartTimeUs; + uint64_t DECLSPEC_ALIGN(8) presentEndTimeUs; + uint64_t DECLSPEC_ALIGN(8) driverStartTimeUs; + uint64_t DECLSPEC_ALIGN(8) driverEndTimeUs; + uint64_t DECLSPEC_ALIGN(8) osRenderQueueStartTimeUs; + uint64_t DECLSPEC_ALIGN(8) osRenderQueueEndTimeUs; + uint64_t DECLSPEC_ALIGN(8) gpuRenderStartTimeUs; + uint64_t DECLSPEC_ALIGN(8) gpuRenderEndTimeUs; +} VkLatencyTimingsFrameReportNV32;

-typedef struct VkVideoDecodeAV1DpbSlotInfoKHR32 +typedef struct VkLayerSettingEXT32 { - VkStructureType sType; - PTR32 pNext; - PTR32 pStdReferenceInfo; -} VkVideoDecodeAV1DpbSlotInfoKHR32; + PTR32 pLayerName; + PTR32 pSettingName; + VkLayerSettingTypeEXT type; + uint32_t valueCount; + PTR32 pValues; +} VkLayerSettingEXT32;

-typedef struct VkVideoEncodeH264DpbSlotInfoKHR32 +typedef struct VkMemoryBarrier232 { VkStructureType sType; PTR32 pNext; - PTR32 pStdReferenceInfo; -} VkVideoEncodeH264DpbSlotInfoKHR32; + VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask; + VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask; + VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask; + VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask; +} VkMemoryBarrier232; +typedef VkMemoryBarrier232 VkMemoryBarrier2KHR32;

-typedef struct VkVideoEncodeAV1DpbSlotInfoKHR32 +typedef struct VkMemoryRequirements32 { - VkStructureType sType; - PTR32 pNext; - PTR32 pStdReferenceInfo; -} VkVideoEncodeAV1DpbSlotInfoKHR32; + VkDeviceSize DECLSPEC_ALIGN(8) size; + VkDeviceSize DECLSPEC_ALIGN(8) alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements32;

-typedef struct VkVideoReferenceIntraRefreshInfoKHR32 +typedef struct VkMemoryToImageCopy32 { VkStructureType sType; PTR32 pNext; - uint32_t dirtyIntraRefreshRegions; -} VkVideoReferenceIntraRefreshInfoKHR32; + PTR32 pHostPointer; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkMemoryToImageCopy32; +typedef VkMemoryToImageCopy32 VkMemoryToImageCopyEXT32;

-typedef struct VkVideoReferenceSlotInfoKHR32 +typedef struct VkMutableDescriptorTypeListEXT32 { - VkStructureType sType; - PTR32 pNext; - int32_t slotIndex; - PTR32 pPictureResource; -} VkVideoReferenceSlotInfoKHR32; + uint32_t descriptorTypeCount; + PTR32 pDescriptorTypes; +} VkMutableDescriptorTypeListEXT32; +typedef VkMutableDescriptorTypeListEXT32 VkMutableDescriptorTypeListVALVE32;

-typedef struct VkVideoEncodeRateControlInfoKHR32 +typedef struct VkPartitionedAccelerationStructureInstancesInputNV32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeRateControlFlagsKHR flags; - VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; - uint32_t layerCount; - PTR32 pLayers; - uint32_t virtualBufferSizeInMs; - uint32_t initialVirtualBufferSizeInMs; -} VkVideoEncodeRateControlInfoKHR32; + VkBuildAccelerationStructureFlagsKHR flags; + uint32_t instanceCount; + uint32_t maxInstancePerPartitionCount; + uint32_t partitionCount; + uint32_t maxInstanceInGlobalPartitionCount; +} VkPartitionedAccelerationStructureInstancesInputNV32; + +typedef union VkPerformanceValueDataINTEL32 +{ + uint32_t value32; + uint64_t DECLSPEC_ALIGN(8) value64; + float valueFloat; + VkBool32 valueBool; + PTR32 valueString; +} VkPerformanceValueDataINTEL32; + +typedef struct VkPhysicalDeviceMemoryProperties32 +{ + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; + uint32_t memoryHeapCount; + VkMemoryHeap32 DECLSPEC_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryProperties32;

-typedef struct VkVideoEncodeH264RateControlInfoKHR32 +typedef struct VkPhysicalDeviceProperties232 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeH264RateControlFlagsKHR flags; - uint32_t gopFrameCount; - uint32_t idrPeriod; - uint32_t consecutiveBFrameCount; - uint32_t temporalLayerCount; -} VkVideoEncodeH264RateControlInfoKHR32; + VkPhysicalDeviceProperties32 DECLSPEC_ALIGN(8) properties; +} VkPhysicalDeviceProperties232; +typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32;

-typedef struct VkVideoEncodeH264GopRemainingFrameInfoKHR32 +typedef struct VkPipelineBinaryKeysAndDataKHR32 { - VkStructureType sType; - PTR32 pNext; - VkBool32 useGopRemainingFrames; - uint32_t gopRemainingI; - uint32_t gopRemainingP; - uint32_t gopRemainingB; -} VkVideoEncodeH264GopRemainingFrameInfoKHR32; + uint32_t binaryCount; + PTR32 pPipelineBinaryKeys; + PTR32 pPipelineBinaryData; +} VkPipelineBinaryKeysAndDataKHR32;

-typedef struct VkVideoEncodeAV1RateControlInfoKHR32 +typedef struct VkPipelineCacheCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeAV1RateControlFlagsKHR flags; - uint32_t gopFrameCount; - uint32_t keyFramePeriod; - uint32_t consecutiveBipredictiveFrameCount; - uint32_t temporalLayerCount; -} VkVideoEncodeAV1RateControlInfoKHR32; + VkPipelineCacheCreateFlags flags; + PTR32 initialDataSize; + PTR32 pInitialData; +} VkPipelineCacheCreateInfo32;

-typedef struct VkVideoEncodeAV1GopRemainingFrameInfoKHR32 +typedef struct VkPipelineColorBlendStateCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 useGopRemainingFrames; - uint32_t gopRemainingIntra; - uint32_t gopRemainingPredictive; - uint32_t gopRemainingBipredictive; -} VkVideoEncodeAV1GopRemainingFrameInfoKHR32; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + PTR32 pAttachments; + float blendConstants[4]; +} VkPipelineColorBlendStateCreateInfo32;

-typedef struct VkVideoBeginCodingInfoKHR32 +typedef struct VkPipelineCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoBeginCodingFlagsKHR flags; - VkVideoSessionKHR DECLSPEC_ALIGN(8) videoSession; - VkVideoSessionParametersKHR DECLSPEC_ALIGN(8) videoSessionParameters; - uint32_t referenceSlotCount; - PTR32 pReferenceSlots; -} VkVideoBeginCodingInfoKHR32; +} VkPipelineCreateInfoKHR32;

-typedef struct VkPipelineLayoutCreateInfo32 +typedef struct VkPipelineCreationFeedback32 { - VkStructureType sType; - PTR32 pNext; - VkPipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - PTR32 pSetLayouts; - uint32_t pushConstantRangeCount; - PTR32 pPushConstantRanges; -} VkPipelineLayoutCreateInfo32; + VkPipelineCreationFeedbackFlags flags; + uint64_t DECLSPEC_ALIGN(8) duration; +} VkPipelineCreationFeedback32; +typedef VkPipelineCreationFeedback32 VkPipelineCreationFeedbackEXT32;

-typedef struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT32 +typedef struct VkPipelineDepthStencilStateCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkShaderStageFlags stageFlags; - VkPipelineLayout DECLSPEC_ALIGN(8) layout; - uint32_t set; -} VkBindDescriptorBufferEmbeddedSamplersInfoEXT32; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} VkPipelineDepthStencilStateCreateInfo32;

-typedef struct VkBufferUsageFlags2CreateInfo32 +typedef struct VkPipelineDynamicStateCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBufferUsageFlags2 DECLSPEC_ALIGN(8) usage; -} VkBufferUsageFlags2CreateInfo32; -typedef VkBufferUsageFlags2CreateInfo32 VkBufferUsageFlags2CreateInfoKHR32; + VkPipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + PTR32 pDynamicStates; +} VkPipelineDynamicStateCreateInfo32;

-typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32 +typedef union VkPipelineExecutableStatisticValueKHR32 { - VkStructureType sType; - PTR32 pNext; - VkBuffer DECLSPEC_ALIGN(8) buffer; -} VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32; + VkBool32 b32; + int64_t i64; + uint64_t DECLSPEC_ALIGN(8) u64; + double f64; +} VkPipelineExecutableStatisticValueKHR32;

-typedef struct VkDescriptorBufferBindingInfoEXT32 +typedef struct VkPipelineInputAssemblyStateCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkDeviceAddress DECLSPEC_ALIGN(8) address; - VkBufferUsageFlags usage; -} VkDescriptorBufferBindingInfoEXT32; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo32;

-typedef struct VkBindDescriptorSetsInfo32 +typedef struct VkPipelineLibraryCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkShaderStageFlags stageFlags; - VkPipelineLayout DECLSPEC_ALIGN(8) layout; - uint32_t firstSet; - uint32_t descriptorSetCount; - PTR32 pDescriptorSets; - uint32_t dynamicOffsetCount; - PTR32 pDynamicOffsets; -} VkBindDescriptorSetsInfo32; -typedef VkBindDescriptorSetsInfo32 VkBindDescriptorSetsInfoKHR32; + uint32_t libraryCount; + PTR32 pLibraries; +} VkPipelineLibraryCreateInfoKHR32;

-typedef struct VkCopyCommandTransformInfoQCOM32 +typedef struct VkPipelineMultisampleStateCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkSurfaceTransformFlagBitsKHR transform; -} VkCopyCommandTransformInfoQCOM32; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + PTR32 pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} VkPipelineMultisampleStateCreateInfo32;

-typedef struct VkImageBlit232 +typedef struct VkPipelineRasterizationStateCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffsets[2]; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffsets[2]; -} VkImageBlit232; -typedef VkImageBlit232 VkImageBlit2KHR32; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} VkPipelineRasterizationStateCreateInfo32;

-typedef struct VkBlitImageCubicWeightsInfoQCOM32 +typedef struct VkPipelineViewportStateCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkCubicFilterWeightsQCOM cubicWeights; -} VkBlitImageCubicWeightsInfoQCOM32; + VkPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + PTR32 pViewports; + uint32_t scissorCount; + PTR32 pScissors; +} VkPipelineViewportStateCreateInfo32;

-typedef struct VkBlitImageInfo232 +typedef struct VkPresentRegionKHR32 +{ + uint32_t rectangleCount; + PTR32 pRectangles; +} VkPresentRegionKHR32; + +typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkImage DECLSPEC_ALIGN(8) srcImage; - VkImageLayout srcImageLayout; - VkImage DECLSPEC_ALIGN(8) dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - PTR32 pRegions; - VkFilter filter; -} VkBlitImageInfo232; -typedef VkBlitImageInfo232 VkBlitImageInfo2KHR32; + uint32_t maxPipelineRayPayloadSize; + uint32_t maxPipelineRayHitAttributeSize; +} VkRayTracingPipelineInterfaceCreateInfoKHR32;

-typedef struct VkGeometryTrianglesNV32 +typedef struct VkRayTracingShaderGroupCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBuffer DECLSPEC_ALIGN(8) vertexData; - VkDeviceSize DECLSPEC_ALIGN(8) vertexOffset; - uint32_t vertexCount; - VkDeviceSize DECLSPEC_ALIGN(8) vertexStride; - VkFormat vertexFormat; - VkBuffer DECLSPEC_ALIGN(8) indexData; - VkDeviceSize DECLSPEC_ALIGN(8) indexOffset; - uint32_t indexCount; - VkIndexType indexType; - VkBuffer DECLSPEC_ALIGN(8) transformData; - VkDeviceSize DECLSPEC_ALIGN(8) transformOffset; -} VkGeometryTrianglesNV32; + VkRayTracingShaderGroupTypeKHR type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; + PTR32 pShaderGroupCaptureReplayHandle; +} VkRayTracingShaderGroupCreateInfoKHR32;

-typedef struct VkGeometryAABBNV32 +typedef struct VkRayTracingShaderGroupCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBuffer DECLSPEC_ALIGN(8) aabbData; - uint32_t numAABBs; - uint32_t stride; - VkDeviceSize DECLSPEC_ALIGN(8) offset; -} VkGeometryAABBNV32; + VkRayTracingShaderGroupTypeKHR type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; +} VkRayTracingShaderGroupCreateInfoNV32;

-typedef struct VkGeometryDataNV32 +typedef struct VkRenderPassStripeInfoARM32 { - VkGeometryTrianglesNV32 DECLSPEC_ALIGN(8) triangles; - VkGeometryAABBNV32 DECLSPEC_ALIGN(8) aabbs; -} VkGeometryDataNV32; + VkStructureType sType; + PTR32 pNext; + VkRect2D stripeArea; +} VkRenderPassStripeInfoARM32;

-typedef struct VkGeometryNV32 +typedef struct VkRenderingAttachmentInfo32 { VkStructureType sType; PTR32 pNext; - VkGeometryTypeKHR geometryType; - VkGeometryDataNV32 DECLSPEC_ALIGN(8) geometry; - VkGeometryFlagsKHR flags; -} VkGeometryNV32; + VkImageView DECLSPEC_ALIGN(8) imageView; + VkImageLayout imageLayout; + VkResolveModeFlagBits resolveMode; + VkImageView DECLSPEC_ALIGN(8) resolveImageView; + VkImageLayout resolveImageLayout; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkClearValue clearValue; +} VkRenderingAttachmentInfo32; +typedef VkRenderingAttachmentInfo32 VkRenderingAttachmentInfoKHR32;

-typedef struct VkAccelerationStructureInfoNV32 +typedef struct VkSemaphoreSubmitInfo32 { VkStructureType sType; PTR32 pNext; - VkAccelerationStructureTypeNV type; - VkBuildAccelerationStructureFlagsNV flags; - uint32_t instanceCount; - uint32_t geometryCount; - PTR32 pGeometries; -} VkAccelerationStructureInfoNV32; + VkSemaphore DECLSPEC_ALIGN(8) semaphore; + uint64_t DECLSPEC_ALIGN(8) value; + VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask; + uint32_t deviceIndex; +} VkSemaphoreSubmitInfo32; +typedef VkSemaphoreSubmitInfo32 VkSemaphoreSubmitInfoKHR32;

-typedef struct VkClusterAccelerationStructureClustersBottomLevelInputNV32 +typedef struct VkShadingRatePaletteNV32 { - VkStructureType sType; - PTR32 pNext; - uint32_t maxTotalClusterCount; - uint32_t maxClusterCountPerAccelerationStructure; -} VkClusterAccelerationStructureClustersBottomLevelInputNV32; + uint32_t shadingRatePaletteEntryCount; + PTR32 pShadingRatePaletteEntries; +} VkShadingRatePaletteNV32;

-typedef struct VkClusterAccelerationStructureTriangleClusterInputNV32 +typedef struct VkSparseBufferMemoryBindInfo32 { - VkStructureType sType; - PTR32 pNext; - VkFormat vertexFormat; - uint32_t maxGeometryIndexValue; - uint32_t maxClusterUniqueGeometryCount; - uint32_t maxClusterTriangleCount; - uint32_t maxClusterVertexCount; - uint32_t maxTotalTriangleCount; - uint32_t maxTotalVertexCount; - uint32_t minPositionTruncateBitCount; -} VkClusterAccelerationStructureTriangleClusterInputNV32; + VkBuffer DECLSPEC_ALIGN(8) buffer; + uint32_t bindCount; + PTR32 pBinds; +} VkSparseBufferMemoryBindInfo32;

-typedef struct VkClusterAccelerationStructureMoveObjectsInputNV32 +typedef struct VkSparseImageMemoryBindInfo32 { - VkStructureType sType; - PTR32 pNext; - VkClusterAccelerationStructureTypeNV type; - VkBool32 noMoveOverlap; - VkDeviceSize DECLSPEC_ALIGN(8) maxMovedBytes; -} VkClusterAccelerationStructureMoveObjectsInputNV32; + VkImage DECLSPEC_ALIGN(8) image; + uint32_t bindCount; + PTR32 pBinds; +} VkSparseImageMemoryBindInfo32;

-typedef union VkClusterAccelerationStructureOpInputNV32 +typedef struct VkSparseImageMemoryRequirements32 { - PTR32 pClustersBottomLevel; - PTR32 pTriangleClusters; - PTR32 pMoveObjects; -} VkClusterAccelerationStructureOpInputNV32; + VkSparseImageFormatProperties formatProperties; + uint32_t imageMipTailFirstLod; + VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailSize; + VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailOffset; + VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailStride; +} VkSparseImageMemoryRequirements32;

-typedef struct VkClusterAccelerationStructureInputInfoNV32 +typedef struct VkSparseImageOpaqueMemoryBindInfo32 { - VkStructureType sType; - PTR32 pNext; - uint32_t maxAccelerationStructureCount; - VkBuildAccelerationStructureFlagsKHR flags; - VkClusterAccelerationStructureOpTypeNV opType; - VkClusterAccelerationStructureOpModeNV opMode; - VkClusterAccelerationStructureOpInputNV32 opInput; -} VkClusterAccelerationStructureInputInfoNV32; + VkImage DECLSPEC_ALIGN(8) image; + uint32_t bindCount; + PTR32 pBinds; +} VkSparseImageOpaqueMemoryBindInfo32;

typedef struct VkStridedDeviceAddressRegionKHR32 { @@ -1092,674 +1440,573 @@ typedef struct VkStridedDeviceAddressRegionKHR32 VkDeviceSize DECLSPEC_ALIGN(8) size; } VkStridedDeviceAddressRegionKHR32;

-typedef struct VkClusterAccelerationStructureCommandsInfoNV32 -{ - VkStructureType sType; - PTR32 pNext; - VkClusterAccelerationStructureInputInfoNV32 input; - VkDeviceAddress DECLSPEC_ALIGN(8) dstImplicitData; - VkDeviceAddress DECLSPEC_ALIGN(8) scratchData; - VkStridedDeviceAddressRegionKHR32 DECLSPEC_ALIGN(8) dstAddressesArray; - VkStridedDeviceAddressRegionKHR32 DECLSPEC_ALIGN(8) dstSizesArray; - VkStridedDeviceAddressRegionKHR32 DECLSPEC_ALIGN(8) srcInfosArray; - VkDeviceAddress DECLSPEC_ALIGN(8) srcInfosCount; - VkClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags; -} VkClusterAccelerationStructureCommandsInfoNV32; - -typedef struct VkPartitionedAccelerationStructureFlagsNV32 +typedef struct VkSubpassDependency232 { VkStructureType sType; PTR32 pNext; - VkBool32 enablePartitionTranslation; -} VkPartitionedAccelerationStructureFlagsNV32; + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; + int32_t viewOffset; +} VkSubpassDependency232; +typedef VkSubpassDependency232 VkSubpassDependency2KHR32;

-typedef struct VkPartitionedAccelerationStructureInstancesInputNV32 +typedef struct VkSubpassDescription32 { - VkStructureType sType; - PTR32 pNext; - VkBuildAccelerationStructureFlagsKHR flags; - uint32_t instanceCount; - uint32_t maxInstancePerPartitionCount; - uint32_t partitionCount; - uint32_t maxInstanceInGlobalPartitionCount; -} VkPartitionedAccelerationStructureInstancesInputNV32; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + PTR32 pInputAttachments; + uint32_t colorAttachmentCount; + PTR32 pColorAttachments; + PTR32 pResolveAttachments; + PTR32 pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + PTR32 pPreserveAttachments; +} VkSubpassDescription32;

-typedef struct VkBuildPartitionedAccelerationStructureInfoNV32 +typedef struct VkSubpassDescription232 { VkStructureType sType; PTR32 pNext; - VkPartitionedAccelerationStructureInstancesInputNV32 input; - VkDeviceAddress DECLSPEC_ALIGN(8) srcAccelerationStructureData; - VkDeviceAddress DECLSPEC_ALIGN(8) dstAccelerationStructureData; - VkDeviceAddress DECLSPEC_ALIGN(8) scratchData; - VkDeviceAddress DECLSPEC_ALIGN(8) srcInfos; - VkDeviceAddress DECLSPEC_ALIGN(8) srcInfosCount; -} VkBuildPartitionedAccelerationStructureInfoNV32; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t viewMask; + uint32_t inputAttachmentCount; + PTR32 pInputAttachments; + uint32_t colorAttachmentCount; + PTR32 pColorAttachments; + PTR32 pResolveAttachments; + PTR32 pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + PTR32 pPreserveAttachments; +} VkSubpassDescription232; +typedef VkSubpassDescription232 VkSubpassDescription2KHR32;

-typedef struct VkVideoEncodeQualityLevelInfoKHR32 +typedef struct VkSubpassSampleLocationsEXT32 { - VkStructureType sType; - PTR32 pNext; - uint32_t qualityLevel; -} VkVideoEncodeQualityLevelInfoKHR32; + uint32_t subpassIndex; + VkSampleLocationsInfoEXT32 sampleLocationsInfo; +} VkSubpassSampleLocationsEXT32;

-typedef struct VkVideoCodingControlInfoKHR32 +typedef struct VkSubresourceLayout32 { - VkStructureType sType; - PTR32 pNext; - VkVideoCodingControlFlagsKHR flags; -} VkVideoCodingControlInfoKHR32; + VkDeviceSize DECLSPEC_ALIGN(8) offset; + VkDeviceSize DECLSPEC_ALIGN(8) size; + VkDeviceSize DECLSPEC_ALIGN(8) rowPitch; + VkDeviceSize DECLSPEC_ALIGN(8) arrayPitch; + VkDeviceSize DECLSPEC_ALIGN(8) depthPitch; +} VkSubresourceLayout32;

-typedef struct VkConvertCooperativeVectorMatrixInfoNV32 +typedef struct VkTensorCopyARM32 { VkStructureType sType; PTR32 pNext; - PTR32 srcSize; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) srcData; - PTR32 pDstSize; - VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dstData; - VkComponentTypeKHR srcComponentType; - VkComponentTypeKHR dstComponentType; - uint32_t numRows; - uint32_t numColumns; - VkCooperativeVectorMatrixLayoutNV srcLayout; - PTR32 srcStride; - VkCooperativeVectorMatrixLayoutNV dstLayout; - PTR32 dstStride; -} VkConvertCooperativeVectorMatrixInfoNV32; + uint32_t dimensionCount; + PTR32 pSrcOffset; + PTR32 pDstOffset; + PTR32 pExtent; +} VkTensorCopyARM32;

-typedef struct VkCopyAccelerationStructureInfoKHR32 +typedef struct VkTensorCreateInfoARM32 { VkStructureType sType; PTR32 pNext; - VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src; - VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst; - VkCopyAccelerationStructureModeKHR mode; -} VkCopyAccelerationStructureInfoKHR32; + VkTensorCreateFlagsARM DECLSPEC_ALIGN(8) flags; + PTR32 pDescription; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + PTR32 pQueueFamilyIndices; +} VkTensorCreateInfoARM32;

-typedef struct VkCopyAccelerationStructureToMemoryInfoKHR32 +typedef struct VkTensorMemoryBarrierARM32 { VkStructureType sType; PTR32 pNext; - VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src; - VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst; - VkCopyAccelerationStructureModeKHR mode; -} VkCopyAccelerationStructureToMemoryInfoKHR32; - -typedef struct VkBufferCopy32 -{ - VkDeviceSize DECLSPEC_ALIGN(8) srcOffset; - VkDeviceSize DECLSPEC_ALIGN(8) dstOffset; - VkDeviceSize DECLSPEC_ALIGN(8) size; -} VkBufferCopy32; + VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask; + VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask; + VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask; + VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkTensorARM DECLSPEC_ALIGN(8) tensor; +} VkTensorMemoryBarrierARM32;

-typedef struct VkBufferCopy232 +typedef struct VkVideoDecodeH264SessionParametersAddInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) srcOffset; - VkDeviceSize DECLSPEC_ALIGN(8) dstOffset; - VkDeviceSize DECLSPEC_ALIGN(8) size; -} VkBufferCopy232; -typedef VkBufferCopy232 VkBufferCopy2KHR32; + uint32_t stdSPSCount; + PTR32 pStdSPSs; + uint32_t stdPPSCount; + PTR32 pStdPPSs; +} VkVideoDecodeH264SessionParametersAddInfoKHR32;

-typedef struct VkCopyBufferInfo232 +typedef struct VkVideoEncodeH264NaluSliceInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBuffer DECLSPEC_ALIGN(8) srcBuffer; - VkBuffer DECLSPEC_ALIGN(8) dstBuffer; - uint32_t regionCount; - PTR32 pRegions; -} VkCopyBufferInfo232; -typedef VkCopyBufferInfo232 VkCopyBufferInfo2KHR32; - -typedef struct VkBufferImageCopy32 -{ - VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkBufferImageCopy32; + int32_t constantQp; + PTR32 pStdSliceHeader; +} VkVideoEncodeH264NaluSliceInfoKHR32;

-typedef struct VkBufferImageCopy232 +typedef struct VkVideoEncodeH264SessionParametersAddInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkBufferImageCopy232; -typedef VkBufferImageCopy232 VkBufferImageCopy2KHR32; + uint32_t stdSPSCount; + PTR32 pStdSPSs; + uint32_t stdPPSCount; + PTR32 pStdPPSs; +} VkVideoEncodeH264SessionParametersAddInfoKHR32;

-typedef struct VkCopyBufferToImageInfo232 +typedef struct VkVideoEncodeRateControlLayerInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBuffer DECLSPEC_ALIGN(8) srcBuffer; - VkImage DECLSPEC_ALIGN(8) dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - PTR32 pRegions; -} VkCopyBufferToImageInfo232; -typedef VkCopyBufferToImageInfo232 VkCopyBufferToImageInfo2KHR32; + uint64_t DECLSPEC_ALIGN(8) averageBitrate; + uint64_t DECLSPEC_ALIGN(8) maxBitrate; + uint32_t frameRateNumerator; + uint32_t frameRateDenominator; +} VkVideoEncodeRateControlLayerInfoKHR32;

-typedef struct VkImageCopy232 +typedef struct VkVideoProfileInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageCopy232; -typedef VkImageCopy232 VkImageCopy2KHR32; + VkVideoCodecOperationFlagBitsKHR videoCodecOperation; + VkVideoChromaSubsamplingFlagsKHR chromaSubsampling; + VkVideoComponentBitDepthFlagsKHR lumaBitDepth; + VkVideoComponentBitDepthFlagsKHR chromaBitDepth; +} VkVideoProfileInfoKHR32;

-typedef struct VkCopyImageInfo232 +typedef struct VkVideoReferenceSlotInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkImage DECLSPEC_ALIGN(8) srcImage; - VkImageLayout srcImageLayout; - VkImage DECLSPEC_ALIGN(8) dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - PTR32 pRegions; -} VkCopyImageInfo232; -typedef VkCopyImageInfo232 VkCopyImageInfo2KHR32; + int32_t slotIndex; + PTR32 pPictureResource; +} VkVideoReferenceSlotInfoKHR32;

-typedef struct VkCopyImageToBufferInfo232 +typedef struct VkWriteDescriptorSet32 { VkStructureType sType; PTR32 pNext; - VkImage DECLSPEC_ALIGN(8) srcImage; - VkImageLayout srcImageLayout; - VkBuffer DECLSPEC_ALIGN(8) dstBuffer; - uint32_t regionCount; - PTR32 pRegions; -} VkCopyImageToBufferInfo232; -typedef VkCopyImageToBufferInfo232 VkCopyImageToBufferInfo2KHR32; + VkDescriptorSet DECLSPEC_ALIGN(8) dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + PTR32 pImageInfo; + PTR32 pBufferInfo; + PTR32 pTexelBufferView; +} VkWriteDescriptorSet32;

-typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32 +typedef struct VkAccelerationStructureBuildGeometryInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src; - VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst; - VkCopyAccelerationStructureModeKHR mode; -} VkCopyMemoryToAccelerationStructureInfoKHR32; + VkAccelerationStructureTypeKHR type; + VkBuildAccelerationStructureFlagsKHR flags; + VkBuildAccelerationStructureModeKHR mode; + VkAccelerationStructureKHR DECLSPEC_ALIGN(8) srcAccelerationStructure; + VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dstAccelerationStructure; + uint32_t geometryCount; + PTR32 pGeometries; + PTR32 ppGeometries; + VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData; +} VkAccelerationStructureBuildGeometryInfoKHR32;

-typedef struct VkCopyMemoryToMicromapInfoEXT32 +typedef struct VkAccelerationStructureBuildSizesInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src; - VkMicromapEXT DECLSPEC_ALIGN(8) dst; - VkCopyMicromapModeEXT mode; -} VkCopyMemoryToMicromapInfoEXT32; + VkDeviceSize DECLSPEC_ALIGN(8) accelerationStructureSize; + VkDeviceSize DECLSPEC_ALIGN(8) updateScratchSize; + VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize; +} VkAccelerationStructureBuildSizesInfoKHR32;

-typedef struct VkCopyMicromapInfoEXT32 +typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkMicromapEXT DECLSPEC_ALIGN(8) src; - VkMicromapEXT DECLSPEC_ALIGN(8) dst; - VkCopyMicromapModeEXT mode; -} VkCopyMicromapInfoEXT32; + VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure; + VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructureNV; +} VkAccelerationStructureCaptureDescriptorDataInfoEXT32;

-typedef struct VkCopyMicromapToMemoryInfoEXT32 +typedef struct VkAccelerationStructureCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkMicromapEXT DECLSPEC_ALIGN(8) src; - VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst; - VkCopyMicromapModeEXT mode; -} VkCopyMicromapToMemoryInfoEXT32; + VkAccelerationStructureCreateFlagsKHR createFlags; + VkBuffer DECLSPEC_ALIGN(8) buffer; + VkDeviceSize DECLSPEC_ALIGN(8) offset; + VkDeviceSize DECLSPEC_ALIGN(8) size; + VkAccelerationStructureTypeKHR type; + VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress; +} VkAccelerationStructureCreateInfoKHR32;

-typedef struct VkTensorCopyARM32 +typedef struct VkAccelerationStructureCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - uint32_t dimensionCount; - PTR32 pSrcOffset; - PTR32 pDstOffset; - PTR32 pExtent; -} VkTensorCopyARM32; + VkDeviceSize DECLSPEC_ALIGN(8) compactedSize; + VkAccelerationStructureInfoNV32 info; +} VkAccelerationStructureCreateInfoNV32;

-typedef struct VkCopyTensorInfoARM32 +typedef struct VkAccelerationStructureDeviceAddressInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkTensorARM DECLSPEC_ALIGN(8) srcTensor; - VkTensorARM DECLSPEC_ALIGN(8) dstTensor; - uint32_t regionCount; - PTR32 pRegions; -} VkCopyTensorInfoARM32; + VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure; +} VkAccelerationStructureDeviceAddressInfoKHR32;

-typedef struct VkCuLaunchInfoNVX32 +typedef struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV32 { VkStructureType sType; PTR32 pNext; - VkCuFunctionNVX DECLSPEC_ALIGN(8) function; - uint32_t gridDimX; - uint32_t gridDimY; - uint32_t gridDimZ; - uint32_t blockDimX; - uint32_t blockDimY; - uint32_t blockDimZ; - uint32_t sharedMemBytes; - PTR32 paramCount; - PTR32 pParams; - PTR32 extraCount; - PTR32 pExtras; -} VkCuLaunchInfoNVX32; + VkFormat vertexFormat; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData; + VkDeviceSize DECLSPEC_ALIGN(8) vertexStride; + VkFormat radiusFormat; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) radiusData; + VkDeviceSize DECLSPEC_ALIGN(8) radiusStride; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData; + VkDeviceSize DECLSPEC_ALIGN(8) indexStride; + VkRayTracingLssIndexingModeNV indexingMode; + VkRayTracingLssPrimitiveEndCapsModeNV endCapsMode; +} VkAccelerationStructureGeometryLinearSweptSpheresDataNV32;

-typedef struct VkDebugMarkerMarkerInfoEXT32 +typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV32 { VkStructureType sType; PTR32 pNext; - PTR32 pMarkerName; - float color[4]; -} VkDebugMarkerMarkerInfoEXT32; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData; +} VkAccelerationStructureGeometryMotionTrianglesDataNV32;

-typedef struct StdVideoDecodeVP9PictureInfo32 +typedef struct VkAccelerationStructureGeometrySpheresDataNV32 { - StdVideoDecodeVP9PictureInfoFlags flags; - StdVideoVP9Profile profile; - StdVideoVP9FrameType frame_type; - uint8_t frame_context_idx; - uint8_t reset_frame_context; - uint8_t refresh_frame_flags; - uint8_t ref_frame_sign_bias_mask; - StdVideoVP9InterpolationFilter interpolation_filter; - uint8_t base_q_idx; - int8_t delta_q_y_dc; - int8_t delta_q_uv_dc; - int8_t delta_q_uv_ac; - uint8_t tile_cols_log2; - uint8_t tile_rows_log2; - uint16_t reserved1[3]; - PTR32 pColorConfig; - PTR32 pLoopFilter; - PTR32 pSegmentation; -} StdVideoDecodeVP9PictureInfo32; + VkStructureType sType; + PTR32 pNext; + VkFormat vertexFormat; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) vertexData; + VkDeviceSize DECLSPEC_ALIGN(8) vertexStride; + VkFormat radiusFormat; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) radiusData; + VkDeviceSize DECLSPEC_ALIGN(8) radiusStride; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexData; + VkDeviceSize DECLSPEC_ALIGN(8) indexStride; +} VkAccelerationStructureGeometrySpheresDataNV32;

-typedef struct StdVideoAV1TileInfo32 +typedef struct VkAccelerationStructureMemoryRequirementsInfoNV32 { - StdVideoAV1TileInfoFlags flags; - uint8_t TileCols; - uint8_t TileRows; - uint16_t context_update_tile_id; - uint8_t tile_size_bytes_minus_1; - uint8_t reserved1[7]; - PTR32 pMiColStarts; - PTR32 pMiRowStarts; - PTR32 pWidthInSbsMinus1; - PTR32 pHeightInSbsMinus1; -} StdVideoAV1TileInfo32; + VkStructureType sType; + PTR32 pNext; + VkAccelerationStructureMemoryRequirementsTypeNV type; + VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure; +} VkAccelerationStructureMemoryRequirementsInfoNV32;

-typedef struct StdVideoDecodeAV1PictureInfo32 -{ - StdVideoDecodeAV1PictureInfoFlags flags; - StdVideoAV1FrameType frame_type; - uint32_t current_frame_id; - uint8_t OrderHint; - uint8_t primary_ref_frame; - uint8_t refresh_frame_flags; - uint8_t reserved1; - StdVideoAV1InterpolationFilter interpolation_filter; - StdVideoAV1TxMode TxMode; - uint8_t delta_q_res; - uint8_t delta_lf_res; - uint8_t SkipModeFrame[STD_VIDEO_AV1_SKIP_MODE_FRAMES]; - uint8_t coded_denom; - uint8_t reserved2[3]; - uint8_t OrderHints[STD_VIDEO_AV1_NUM_REF_FRAMES]; - uint32_t expectedFrameId[STD_VIDEO_AV1_NUM_REF_FRAMES]; - PTR32 pTileInfo; - PTR32 pQuantization; - PTR32 pSegmentation; - PTR32 pLoopFilter; - PTR32 pCDEF; - PTR32 pLoopRestoration; - PTR32 pGlobalMotion; - PTR32 pFilmGrain; -} StdVideoDecodeAV1PictureInfo32; +typedef struct VkAccelerationStructureMotionInfoNV32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t maxInstances; + VkAccelerationStructureMotionInfoFlagsNV flags; +} VkAccelerationStructureMotionInfoNV32;

-typedef struct VkVideoInlineQueryInfoKHR32 +typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT32 { VkStructureType sType; PTR32 pNext; - VkQueryPool DECLSPEC_ALIGN(8) queryPool; - uint32_t firstQuery; - uint32_t queryCount; -} VkVideoInlineQueryInfoKHR32; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) indexBuffer; + VkDeviceSize DECLSPEC_ALIGN(8) indexStride; + uint32_t baseTriangle; + uint32_t usageCountsCount; + PTR32 pUsageCounts; + PTR32 ppUsageCounts; + VkMicromapEXT DECLSPEC_ALIGN(8) micromap; +} VkAccelerationStructureTrianglesOpacityMicromapEXT32;

-typedef struct VkVideoDecodeH264PictureInfoKHR32 +typedef struct VkAccelerationStructureVersionInfoKHR32 { VkStructureType sType; PTR32 pNext; - PTR32 pStdPictureInfo; - uint32_t sliceCount; - PTR32 pSliceOffsets; -} VkVideoDecodeH264PictureInfoKHR32; + PTR32 pVersionData; +} VkAccelerationStructureVersionInfoKHR32;

-typedef struct VkVideoDecodeVP9PictureInfoKHR32 +typedef struct VkAcquireNextImageInfoKHR32 { VkStructureType sType; PTR32 pNext; - PTR32 pStdPictureInfo; - int32_t referenceNameSlotIndices[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR]; - uint32_t uncompressedHeaderOffset; - uint32_t compressedHeaderOffset; - uint32_t tilesOffset; -} VkVideoDecodeVP9PictureInfoKHR32; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; + uint64_t DECLSPEC_ALIGN(8) timeout; + VkSemaphore DECLSPEC_ALIGN(8) semaphore; + VkFence DECLSPEC_ALIGN(8) fence; + uint32_t deviceMask; +} VkAcquireNextImageInfoKHR32;

-typedef struct VkVideoDecodeAV1PictureInfoKHR32 +typedef struct VkAcquireProfilingLockInfoKHR32 { VkStructureType sType; PTR32 pNext; - PTR32 pStdPictureInfo; - int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; - uint32_t frameHeaderOffset; - uint32_t tileCount; - PTR32 pTileOffsets; - PTR32 pTileSizes; -} VkVideoDecodeAV1PictureInfoKHR32; + VkAcquireProfilingLockFlagsKHR flags; + uint64_t DECLSPEC_ALIGN(8) timeout; +} VkAcquireProfilingLockInfoKHR32;

-typedef struct VkVideoDecodeInfoKHR32 +typedef struct VkAntiLagDataAMD32 { VkStructureType sType; PTR32 pNext; - VkVideoDecodeFlagsKHR flags; - VkBuffer DECLSPEC_ALIGN(8) srcBuffer; - VkDeviceSize DECLSPEC_ALIGN(8) srcBufferOffset; - VkDeviceSize DECLSPEC_ALIGN(8) srcBufferRange; - VkVideoPictureResourceInfoKHR32 DECLSPEC_ALIGN(8) dstPictureResource; - PTR32 pSetupReferenceSlot; - uint32_t referenceSlotCount; - PTR32 pReferenceSlots; -} VkVideoDecodeInfoKHR32; + VkAntiLagModeAMD mode; + uint32_t maxFPS; + PTR32 pPresentationInfo; +} VkAntiLagDataAMD32;

-typedef struct VkDecompressMemoryRegionNV32 +typedef struct VkAttachmentDescriptionStencilLayout32 { - VkDeviceAddress DECLSPEC_ALIGN(8) srcAddress; - VkDeviceAddress DECLSPEC_ALIGN(8) dstAddress; - VkDeviceSize DECLSPEC_ALIGN(8) compressedSize; - VkDeviceSize DECLSPEC_ALIGN(8) decompressedSize; - VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethod; -} VkDecompressMemoryRegionNV32; + VkStructureType sType; + PTR32 pNext; + VkImageLayout stencilInitialLayout; + VkImageLayout stencilFinalLayout; +} VkAttachmentDescriptionStencilLayout32; +typedef VkAttachmentDescriptionStencilLayout32 VkAttachmentDescriptionStencilLayoutKHR32;

-typedef struct VkDataGraphPipelineDispatchInfoARM32 +typedef struct VkAttachmentFeedbackLoopInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkDataGraphPipelineDispatchFlagsARM DECLSPEC_ALIGN(8) flags; -} VkDataGraphPipelineDispatchInfoARM32; + VkBool32 feedbackLoopEnable; +} VkAttachmentFeedbackLoopInfoEXT32;

-typedef struct VkDispatchTileInfoQCOM32 +typedef struct VkAttachmentReferenceStencilLayout32 { VkStructureType sType; PTR32 pNext; -} VkDispatchTileInfoQCOM32; + VkImageLayout stencilLayout; +} VkAttachmentReferenceStencilLayout32; +typedef VkAttachmentReferenceStencilLayout32 VkAttachmentReferenceStencilLayoutKHR32;

-typedef struct StdVideoEncodeH264SliceHeader32 +typedef struct VkAttachmentSampleCountInfoAMD32 { - StdVideoEncodeH264SliceHeaderFlags flags; - uint32_t first_mb_in_slice; - StdVideoH264SliceType slice_type; - int8_t slice_alpha_c0_offset_div2; - int8_t slice_beta_offset_div2; - int8_t slice_qp_delta; - uint8_t reserved1; - StdVideoH264CabacInitIdc cabac_init_idc; - StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc; - PTR32 pWeightTable; -} StdVideoEncodeH264SliceHeader32; + VkStructureType sType; + PTR32 pNext; + uint32_t colorAttachmentCount; + PTR32 pColorAttachmentSamples; + VkSampleCountFlagBits depthStencilAttachmentSamples; +} VkAttachmentSampleCountInfoAMD32; +typedef VkAttachmentSampleCountInfoAMD32 VkAttachmentSampleCountInfoNV32;

-typedef struct VkVideoEncodeH264NaluSliceInfoKHR32 +typedef struct VkBindAccelerationStructureMemoryInfoNV32 { VkStructureType sType; PTR32 pNext; - int32_t constantQp; - PTR32 pStdSliceHeader; -} VkVideoEncodeH264NaluSliceInfoKHR32; + VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; + VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; + uint32_t deviceIndexCount; + PTR32 pDeviceIndices; +} VkBindAccelerationStructureMemoryInfoNV32;

-typedef struct StdVideoEncodeH264ReferenceListsInfo32 +typedef struct VkBindBufferMemoryDeviceGroupInfo32 { - StdVideoEncodeH264ReferenceListsInfoFlags flags; - uint8_t num_ref_idx_l0_active_minus1; - uint8_t num_ref_idx_l1_active_minus1; - uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF]; - uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF]; - uint8_t refList0ModOpCount; - uint8_t refList1ModOpCount; - uint8_t refPicMarkingOpCount; - uint8_t reserved1[7]; - PTR32 pRefList0ModOperations; - PTR32 pRefList1ModOperations; - PTR32 pRefPicMarkingOperations; -} StdVideoEncodeH264ReferenceListsInfo32; + VkStructureType sType; + PTR32 pNext; + uint32_t deviceIndexCount; + PTR32 pDeviceIndices; +} VkBindBufferMemoryDeviceGroupInfo32; +typedef VkBindBufferMemoryDeviceGroupInfo32 VkBindBufferMemoryDeviceGroupInfoKHR32;

-typedef struct StdVideoEncodeH264PictureInfo32 +typedef struct VkBindBufferMemoryInfo32 { - StdVideoEncodeH264PictureInfoFlags flags; - uint8_t seq_parameter_set_id; - uint8_t pic_parameter_set_id; - uint16_t idr_pic_id; - StdVideoH264PictureType primary_pic_type; - uint32_t frame_num; - int32_t PicOrderCnt; - uint8_t temporal_id; - uint8_t reserved1[3]; - PTR32 pRefLists; -} StdVideoEncodeH264PictureInfo32; + VkStructureType sType; + PTR32 pNext; + VkBuffer DECLSPEC_ALIGN(8) buffer; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; + VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; +} VkBindBufferMemoryInfo32; +typedef VkBindBufferMemoryInfo32 VkBindBufferMemoryInfoKHR32;

-typedef struct StdVideoEncodeAV1PictureInfo32 +typedef struct VkBindDataGraphPipelineSessionMemoryInfoARM32 { - StdVideoEncodeAV1PictureInfoFlags flags; - StdVideoAV1FrameType frame_type; - uint32_t frame_presentation_time; - uint32_t current_frame_id; - uint8_t order_hint; - uint8_t primary_ref_frame; - uint8_t refresh_frame_flags; - uint8_t coded_denom; - uint16_t render_width_minus_1; - uint16_t render_height_minus_1; - StdVideoAV1InterpolationFilter interpolation_filter; - StdVideoAV1TxMode TxMode; - uint8_t delta_q_res; - uint8_t delta_lf_res; - uint8_t ref_order_hint[STD_VIDEO_AV1_NUM_REF_FRAMES]; - int8_t ref_frame_idx[STD_VIDEO_AV1_REFS_PER_FRAME]; - uint8_t reserved1[3]; - uint32_t delta_frame_id_minus_1[STD_VIDEO_AV1_REFS_PER_FRAME]; - PTR32 pTileInfo; - PTR32 pQuantization; - PTR32 pSegmentation; - PTR32 pLoopFilter; - PTR32 pCDEF; - PTR32 pLoopRestoration; - PTR32 pGlobalMotion; - PTR32 pExtensionHeader; - PTR32 pBufferRemovalTimes; -} StdVideoEncodeAV1PictureInfo32; + VkStructureType sType; + PTR32 pNext; + VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session; + VkDataGraphPipelineSessionBindPointARM bindPoint; + uint32_t objectIndex; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; + VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; +} VkBindDataGraphPipelineSessionMemoryInfoARM32;

-typedef struct VkVideoEncodeQuantizationMapInfoKHR32 +typedef struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkImageView DECLSPEC_ALIGN(8) quantizationMap; - VkExtent2D quantizationMapExtent; -} VkVideoEncodeQuantizationMapInfoKHR32; + VkShaderStageFlags stageFlags; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t set; +} VkBindDescriptorBufferEmbeddedSamplersInfoEXT32;

-typedef struct VkVideoEncodeH264PictureInfoKHR32 +typedef struct VkBindDescriptorSetsInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t naluSliceEntryCount; - PTR32 pNaluSliceEntries; - PTR32 pStdPictureInfo; - VkBool32 generatePrefixNalu; -} VkVideoEncodeH264PictureInfoKHR32; + VkShaderStageFlags stageFlags; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t firstSet; + uint32_t descriptorSetCount; + PTR32 pDescriptorSets; + uint32_t dynamicOffsetCount; + PTR32 pDynamicOffsets; +} VkBindDescriptorSetsInfo32; +typedef VkBindDescriptorSetsInfo32 VkBindDescriptorSetsInfoKHR32;

-typedef struct VkVideoEncodeAV1PictureInfoKHR32 +typedef struct VkBindImageMemoryDeviceGroupInfo32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeAV1PredictionModeKHR predictionMode; - VkVideoEncodeAV1RateControlGroupKHR rateControlGroup; - uint32_t constantQIndex; - PTR32 pStdPictureInfo; - int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; - VkBool32 primaryReferenceCdfOnly; - VkBool32 generateObuExtensionHeader; -} VkVideoEncodeAV1PictureInfoKHR32; + uint32_t deviceIndexCount; + PTR32 pDeviceIndices; + uint32_t splitInstanceBindRegionCount; + PTR32 pSplitInstanceBindRegions; +} VkBindImageMemoryDeviceGroupInfo32; +typedef VkBindImageMemoryDeviceGroupInfo32 VkBindImageMemoryDeviceGroupInfoKHR32;

-typedef struct VkVideoEncodeIntraRefreshInfoKHR32 +typedef struct VkBindImageMemoryInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t intraRefreshCycleDuration; - uint32_t intraRefreshIndex; -} VkVideoEncodeIntraRefreshInfoKHR32; + VkImage DECLSPEC_ALIGN(8) image; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; + VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; +} VkBindImageMemoryInfo32; +typedef VkBindImageMemoryInfo32 VkBindImageMemoryInfoKHR32;

-typedef struct VkVideoEncodeInfoKHR32 +typedef struct VkBindImageMemorySwapchainInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeFlagsKHR flags; - VkBuffer DECLSPEC_ALIGN(8) dstBuffer; - VkDeviceSize DECLSPEC_ALIGN(8) dstBufferOffset; - VkDeviceSize DECLSPEC_ALIGN(8) dstBufferRange; - VkVideoPictureResourceInfoKHR32 DECLSPEC_ALIGN(8) srcPictureResource; - PTR32 pSetupReferenceSlot; - uint32_t referenceSlotCount; - PTR32 pReferenceSlots; - uint32_t precedingExternallyEncodedBytes; -} VkVideoEncodeInfoKHR32; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; + uint32_t imageIndex; +} VkBindImageMemorySwapchainInfoKHR32;

-typedef struct VkPerTileEndInfoQCOM32 +typedef struct VkBindImagePlaneMemoryInfo32 { VkStructureType sType; PTR32 pNext; -} VkPerTileEndInfoQCOM32; + VkImageAspectFlagBits planeAspect; +} VkBindImagePlaneMemoryInfo32; +typedef VkBindImagePlaneMemoryInfo32 VkBindImagePlaneMemoryInfoKHR32;

-typedef struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT32 +typedef struct VkBindMemoryStatus32 { VkStructureType sType; PTR32 pNext; - uint32_t fragmentDensityOffsetCount; - PTR32 pFragmentDensityOffsets; -} VkRenderPassFragmentDensityMapOffsetEndInfoEXT32; -typedef VkRenderPassFragmentDensityMapOffsetEndInfoEXT32 VkSubpassFragmentDensityMapOffsetEndInfoQCOM32; + PTR32 pResult; +} VkBindMemoryStatus32; +typedef VkBindMemoryStatus32 VkBindMemoryStatusKHR32;

-typedef struct VkSubpassEndInfo32 +typedef struct VkBindSparseInfo32 { VkStructureType sType; PTR32 pNext; -} VkSubpassEndInfo32; -typedef VkSubpassEndInfo32 VkSubpassEndInfoKHR32; + uint32_t waitSemaphoreCount; + PTR32 pWaitSemaphores; + uint32_t bufferBindCount; + PTR32 pBufferBinds; + uint32_t imageOpaqueBindCount; + PTR32 pImageOpaqueBinds; + uint32_t imageBindCount; + PTR32 pImageBinds; + uint32_t signalSemaphoreCount; + PTR32 pSignalSemaphores; +} VkBindSparseInfo32;

-typedef struct VkRenderingEndInfoEXT32 +typedef struct VkBindTensorMemoryInfoARM32 { VkStructureType sType; PTR32 pNext; -} VkRenderingEndInfoEXT32; + VkTensorARM DECLSPEC_ALIGN(8) tensor; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; + VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; +} VkBindTensorMemoryInfoARM32;

-typedef struct VkVideoEndCodingInfoKHR32 +typedef struct VkBindVideoSessionMemoryInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoEndCodingFlagsKHR flags; -} VkVideoEndCodingInfoKHR32; + uint32_t memoryBindIndex; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; + VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; + VkDeviceSize DECLSPEC_ALIGN(8) memorySize; +} VkBindVideoSessionMemoryInfoKHR32;

-typedef struct VkGeneratedCommandsPipelineInfoEXT32 +typedef struct VkBlitImageCubicWeightsInfoQCOM32 { VkStructureType sType; PTR32 pNext; - VkPipeline DECLSPEC_ALIGN(8) pipeline; -} VkGeneratedCommandsPipelineInfoEXT32; + VkCubicFilterWeightsQCOM cubicWeights; +} VkBlitImageCubicWeightsInfoQCOM32;

-typedef struct VkGeneratedCommandsShaderInfoEXT32 +typedef struct VkBlitImageInfo232 { VkStructureType sType; PTR32 pNext; - uint32_t shaderCount; - PTR32 pShaders; -} VkGeneratedCommandsShaderInfoEXT32; + VkImage DECLSPEC_ALIGN(8) srcImage; + VkImageLayout srcImageLayout; + VkImage DECLSPEC_ALIGN(8) dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + PTR32 pRegions; + VkFilter filter; +} VkBlitImageInfo232; +typedef VkBlitImageInfo232 VkBlitImageInfo2KHR32;

-typedef struct VkGeneratedCommandsInfoEXT32 +typedef struct VkBufferCaptureDescriptorDataInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkShaderStageFlags shaderStages; - VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet; - VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout; - VkDeviceAddress DECLSPEC_ALIGN(8) indirectAddress; - VkDeviceSize DECLSPEC_ALIGN(8) indirectAddressSize; - VkDeviceAddress DECLSPEC_ALIGN(8) preprocessAddress; - VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize; - uint32_t maxSequenceCount; - VkDeviceAddress DECLSPEC_ALIGN(8) sequenceCountAddress; - uint32_t maxDrawCount; -} VkGeneratedCommandsInfoEXT32; - -typedef struct VkIndirectCommandsStreamNV32 -{ VkBuffer DECLSPEC_ALIGN(8) buffer; - VkDeviceSize DECLSPEC_ALIGN(8) offset; -} VkIndirectCommandsStreamNV32; +} VkBufferCaptureDescriptorDataInfoEXT32;

-typedef struct VkGeneratedCommandsInfoNV32 +typedef struct VkBufferCopy32 { - VkStructureType sType; - PTR32 pNext; - VkPipelineBindPoint pipelineBindPoint; - VkPipeline DECLSPEC_ALIGN(8) pipeline; - VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout; - uint32_t streamCount; - PTR32 pStreams; - uint32_t sequencesCount; - VkBuffer DECLSPEC_ALIGN(8) preprocessBuffer; - VkDeviceSize DECLSPEC_ALIGN(8) preprocessOffset; - VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize; - VkBuffer DECLSPEC_ALIGN(8) sequencesCountBuffer; - VkDeviceSize DECLSPEC_ALIGN(8) sequencesCountOffset; - VkBuffer DECLSPEC_ALIGN(8) sequencesIndexBuffer; - VkDeviceSize DECLSPEC_ALIGN(8) sequencesIndexOffset; -} VkGeneratedCommandsInfoNV32; + VkDeviceSize DECLSPEC_ALIGN(8) srcOffset; + VkDeviceSize DECLSPEC_ALIGN(8) dstOffset; + VkDeviceSize DECLSPEC_ALIGN(8) size; +} VkBufferCopy32;

-typedef struct VkOpticalFlowExecuteInfoNV32 +typedef struct VkBufferDeviceAddressCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkOpticalFlowExecuteFlagsNV flags; - uint32_t regionCount; - PTR32 pRegions; -} VkOpticalFlowExecuteInfoNV32; + VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress; +} VkBufferDeviceAddressCreateInfoEXT32;

-typedef struct VkMemoryBarrier32 +typedef struct VkBufferDeviceAddressInfo32 { VkStructureType sType; PTR32 pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; -} VkMemoryBarrier32; + VkBuffer DECLSPEC_ALIGN(8) buffer; +} VkBufferDeviceAddressInfo32; +typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoKHR32; +typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoEXT32;

-typedef struct VkExternalMemoryAcquireUnmodifiedEXT32 +typedef struct VkBufferImageCopy32 { - VkStructureType sType; - PTR32 pNext; - VkBool32 acquireUnmodifiedMemory; -} VkExternalMemoryAcquireUnmodifiedEXT32; + VkDeviceSize DECLSPEC_ALIGN(8) bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy32;

typedef struct VkBufferMemoryBarrier32 { @@ -1774,321 +2021,343 @@ typedef struct VkBufferMemoryBarrier32 VkDeviceSize DECLSPEC_ALIGN(8) size; } VkBufferMemoryBarrier32;

-typedef struct VkImageMemoryBarrier32 +typedef struct VkBufferMemoryRequirementsInfo232 { VkStructureType sType; PTR32 pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkImageLayout oldLayout; - VkImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkImage DECLSPEC_ALIGN(8) image; - VkImageSubresourceRange subresourceRange; -} VkImageMemoryBarrier32; + VkBuffer DECLSPEC_ALIGN(8) buffer; +} VkBufferMemoryRequirementsInfo232; +typedef VkBufferMemoryRequirementsInfo232 VkBufferMemoryRequirementsInfo2KHR32;

-typedef struct VkTensorMemoryBarrierARM32 +typedef struct VkBufferOpaqueCaptureAddressCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask; - VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask; - VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask; - VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkTensorARM DECLSPEC_ALIGN(8) tensor; -} VkTensorMemoryBarrierARM32; + uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress; +} VkBufferOpaqueCaptureAddressCreateInfo32; +typedef VkBufferOpaqueCaptureAddressCreateInfo32 VkBufferOpaqueCaptureAddressCreateInfoKHR32;

-typedef struct VkMemoryBarrier232 +typedef struct VkBufferUsageFlags2CreateInfo32 { VkStructureType sType; PTR32 pNext; - VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask; - VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask; - VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask; - VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask; -} VkMemoryBarrier232; -typedef VkMemoryBarrier232 VkMemoryBarrier2KHR32; + VkBufferUsageFlags2 DECLSPEC_ALIGN(8) usage; +} VkBufferUsageFlags2CreateInfo32; +typedef VkBufferUsageFlags2CreateInfo32 VkBufferUsageFlags2CreateInfoKHR32;

-typedef struct VkMemoryBarrierAccessFlags3KHR32 +typedef struct VkBufferViewCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkAccessFlags3KHR DECLSPEC_ALIGN(8) srcAccessMask3; - VkAccessFlags3KHR DECLSPEC_ALIGN(8) dstAccessMask3; -} VkMemoryBarrierAccessFlags3KHR32; + VkBufferViewCreateFlags flags; + VkBuffer DECLSPEC_ALIGN(8) buffer; + VkFormat format; + VkDeviceSize DECLSPEC_ALIGN(8) offset; + VkDeviceSize DECLSPEC_ALIGN(8) range; +} VkBufferViewCreateInfo32;

-typedef struct VkBufferMemoryBarrier232 +typedef struct VkBuildPartitionedAccelerationStructureInfoNV32 { VkStructureType sType; PTR32 pNext; - VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask; - VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask; - VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask; - VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkBuffer DECLSPEC_ALIGN(8) buffer; - VkDeviceSize DECLSPEC_ALIGN(8) offset; - VkDeviceSize DECLSPEC_ALIGN(8) size; -} VkBufferMemoryBarrier232; -typedef VkBufferMemoryBarrier232 VkBufferMemoryBarrier2KHR32; + VkPartitionedAccelerationStructureInstancesInputNV32 input; + VkDeviceAddress DECLSPEC_ALIGN(8) srcAccelerationStructureData; + VkDeviceAddress DECLSPEC_ALIGN(8) dstAccelerationStructureData; + VkDeviceAddress DECLSPEC_ALIGN(8) scratchData; + VkDeviceAddress DECLSPEC_ALIGN(8) srcInfos; + VkDeviceAddress DECLSPEC_ALIGN(8) srcInfosCount; +} VkBuildPartitionedAccelerationStructureInfoNV32;

-typedef struct VkImageMemoryBarrier232 +typedef struct VkCalibratedTimestampInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkPipelineStageFlags2 DECLSPEC_ALIGN(8) srcStageMask; - VkAccessFlags2 DECLSPEC_ALIGN(8) srcAccessMask; - VkPipelineStageFlags2 DECLSPEC_ALIGN(8) dstStageMask; - VkAccessFlags2 DECLSPEC_ALIGN(8) dstAccessMask; - VkImageLayout oldLayout; - VkImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkImage DECLSPEC_ALIGN(8) image; - VkImageSubresourceRange subresourceRange; -} VkImageMemoryBarrier232; -typedef VkImageMemoryBarrier232 VkImageMemoryBarrier2KHR32; + VkTimeDomainKHR timeDomain; +} VkCalibratedTimestampInfoKHR32; +typedef VkCalibratedTimestampInfoKHR32 VkCalibratedTimestampInfoEXT32;

-typedef struct VkTensorDependencyInfoARM32 +typedef struct VkCheckpointData2NV32 +{ + VkStructureType sType; + PTR32 pNext; + VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage; + PTR32 pCheckpointMarker; +} VkCheckpointData2NV32; + +typedef struct VkCheckpointDataNV32 +{ + VkStructureType sType; + PTR32 pNext; + VkPipelineStageFlagBits stage; + PTR32 pCheckpointMarker; +} VkCheckpointDataNV32; + +typedef struct VkClusterAccelerationStructureCommandsInfoNV32 { VkStructureType sType; PTR32 pNext; - uint32_t tensorMemoryBarrierCount; - PTR32 pTensorMemoryBarriers; -} VkTensorDependencyInfoARM32; + VkClusterAccelerationStructureInputInfoNV32 input; + VkDeviceAddress DECLSPEC_ALIGN(8) dstImplicitData; + VkDeviceAddress DECLSPEC_ALIGN(8) scratchData; + VkStridedDeviceAddressRegionKHR32 DECLSPEC_ALIGN(8) dstAddressesArray; + VkStridedDeviceAddressRegionKHR32 DECLSPEC_ALIGN(8) dstSizesArray; + VkStridedDeviceAddressRegionKHR32 DECLSPEC_ALIGN(8) srcInfosArray; + VkDeviceAddress DECLSPEC_ALIGN(8) srcInfosCount; + VkClusterAccelerationStructureAddressResolutionFlagsNV addressResolutionFlags; +} VkClusterAccelerationStructureCommandsInfoNV32;

-typedef struct VkDependencyInfo32 +typedef struct VkCommandBufferAllocateInfo32 { VkStructureType sType; PTR32 pNext; - VkDependencyFlags dependencyFlags; - uint32_t memoryBarrierCount; - PTR32 pMemoryBarriers; - uint32_t bufferMemoryBarrierCount; - PTR32 pBufferMemoryBarriers; - uint32_t imageMemoryBarrierCount; - PTR32 pImageMemoryBarriers; -} VkDependencyInfo32; -typedef VkDependencyInfo32 VkDependencyInfoKHR32; + VkCommandPool DECLSPEC_ALIGN(8) commandPool; + VkCommandBufferLevel level; + uint32_t commandBufferCount; +} VkCommandBufferAllocateInfo32;

-typedef struct VkPushConstantsInfo32 +typedef struct VkCommandBufferBeginInfo32 { VkStructureType sType; PTR32 pNext; - VkPipelineLayout DECLSPEC_ALIGN(8) layout; - VkShaderStageFlags stageFlags; - uint32_t offset; - uint32_t size; - PTR32 pValues; -} VkPushConstantsInfo32; -typedef VkPushConstantsInfo32 VkPushConstantsInfoKHR32; + VkCommandBufferUsageFlags flags; + PTR32 pInheritanceInfo; +} VkCommandBufferBeginInfo32;

-typedef struct VkDescriptorImageInfo32 +typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT32 { - VkSampler DECLSPEC_ALIGN(8) sampler; - VkImageView DECLSPEC_ALIGN(8) imageView; - VkImageLayout imageLayout; -} VkDescriptorImageInfo32; + VkStructureType sType; + PTR32 pNext; + VkBool32 conditionalRenderingEnable; +} VkCommandBufferInheritanceConditionalRenderingInfoEXT32;

-typedef struct VkDescriptorBufferInfo32 +typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM32 { - VkBuffer DECLSPEC_ALIGN(8) buffer; - VkDeviceSize DECLSPEC_ALIGN(8) offset; - VkDeviceSize DECLSPEC_ALIGN(8) range; -} VkDescriptorBufferInfo32; + VkStructureType sType; + PTR32 pNext; + VkSurfaceTransformFlagBitsKHR transform; + VkRect2D renderArea; +} VkCommandBufferInheritanceRenderPassTransformInfoQCOM32;

-typedef struct VkWriteDescriptorSetInlineUniformBlock32 +typedef struct VkCommandBufferInheritanceRenderingInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t dataSize; - PTR32 pData; -} VkWriteDescriptorSetInlineUniformBlock32; -typedef VkWriteDescriptorSetInlineUniformBlock32 VkWriteDescriptorSetInlineUniformBlockEXT32; + VkRenderingFlags flags; + uint32_t viewMask; + uint32_t colorAttachmentCount; + PTR32 pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; + VkSampleCountFlagBits rasterizationSamples; +} VkCommandBufferInheritanceRenderingInfo32; +typedef VkCommandBufferInheritanceRenderingInfo32 VkCommandBufferInheritanceRenderingInfoKHR32;

-typedef struct VkWriteDescriptorSetAccelerationStructureKHR32 +typedef struct VkCommandBufferInheritanceViewportScissorInfoNV32 { VkStructureType sType; PTR32 pNext; - uint32_t accelerationStructureCount; - PTR32 pAccelerationStructures; -} VkWriteDescriptorSetAccelerationStructureKHR32; + VkBool32 viewportScissor2D; + uint32_t viewportDepthCount; + PTR32 pViewportDepths; +} VkCommandBufferInheritanceViewportScissorInfoNV32;

-typedef struct VkWriteDescriptorSetAccelerationStructureNV32 +typedef struct VkCommandPoolCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t accelerationStructureCount; - PTR32 pAccelerationStructures; -} VkWriteDescriptorSetAccelerationStructureNV32; + VkCommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; +} VkCommandPoolCreateInfo32;

-typedef struct VkWriteDescriptorSetPartitionedAccelerationStructureNV32 +typedef struct VkComputePipelineCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t accelerationStructureCount; - PTR32 pAccelerationStructures; -} VkWriteDescriptorSetPartitionedAccelerationStructureNV32; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo32 DECLSPEC_ALIGN(8) stage; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo32;

-typedef struct VkWriteDescriptorSetTensorARM32 +typedef struct VkComputePipelineIndirectBufferInfoNV32 { VkStructureType sType; PTR32 pNext; - uint32_t tensorViewCount; - PTR32 pTensorViews; -} VkWriteDescriptorSetTensorARM32; + VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress; + VkDeviceSize DECLSPEC_ALIGN(8) size; + VkDeviceAddress DECLSPEC_ALIGN(8) pipelineDeviceAddressCaptureReplay; +} VkComputePipelineIndirectBufferInfoNV32;

-typedef struct VkWriteDescriptorSet32 +typedef struct VkConditionalRenderingBeginInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkDescriptorSet DECLSPEC_ALIGN(8) dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - PTR32 pImageInfo; - PTR32 pBufferInfo; - PTR32 pTexelBufferView; -} VkWriteDescriptorSet32; + VkBuffer DECLSPEC_ALIGN(8) buffer; + VkDeviceSize DECLSPEC_ALIGN(8) offset; + VkConditionalRenderingFlagsEXT flags; +} VkConditionalRenderingBeginInfoEXT32;

-typedef struct VkPushDescriptorSetInfo32 +typedef struct VkConvertCooperativeVectorMatrixInfoNV32 { VkStructureType sType; PTR32 pNext; - VkShaderStageFlags stageFlags; - VkPipelineLayout DECLSPEC_ALIGN(8) layout; - uint32_t set; - uint32_t descriptorWriteCount; - PTR32 pDescriptorWrites; -} VkPushDescriptorSetInfo32; -typedef VkPushDescriptorSetInfo32 VkPushDescriptorSetInfoKHR32; + PTR32 srcSize; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) srcData; + PTR32 pDstSize; + VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dstData; + VkComponentTypeKHR srcComponentType; + VkComponentTypeKHR dstComponentType; + uint32_t numRows; + uint32_t numColumns; + VkCooperativeVectorMatrixLayoutNV srcLayout; + PTR32 srcStride; + VkCooperativeVectorMatrixLayoutNV dstLayout; + PTR32 dstStride; +} VkConvertCooperativeVectorMatrixInfoNV32;

-typedef struct VkPushDescriptorSetWithTemplateInfo32 +typedef struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate; - VkPipelineLayout DECLSPEC_ALIGN(8) layout; - uint32_t set; - PTR32 pData; -} VkPushDescriptorSetWithTemplateInfo32; -typedef VkPushDescriptorSetWithTemplateInfo32 VkPushDescriptorSetWithTemplateInfoKHR32; + uint32_t MGranularity; + uint32_t NGranularity; + uint32_t KGranularity; + VkComponentTypeKHR AType; + VkComponentTypeKHR BType; + VkComponentTypeKHR CType; + VkComponentTypeKHR ResultType; + VkBool32 saturatingAccumulation; + VkScopeKHR scope; + uint32_t workgroupInvocations; +} VkCooperativeMatrixFlexibleDimensionsPropertiesNV32;

-typedef struct VkImageResolve232 +typedef struct VkCooperativeMatrixPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageResolve232; -typedef VkImageResolve232 VkImageResolve2KHR32; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + VkComponentTypeKHR AType; + VkComponentTypeKHR BType; + VkComponentTypeKHR CType; + VkComponentTypeKHR ResultType; + VkBool32 saturatingAccumulation; + VkScopeKHR scope; +} VkCooperativeMatrixPropertiesKHR32;

-typedef struct VkResolveImageInfo232 +typedef struct VkCooperativeMatrixPropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkImage DECLSPEC_ALIGN(8) srcImage; - VkImageLayout srcImageLayout; - VkImage DECLSPEC_ALIGN(8) dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - PTR32 pRegions; -} VkResolveImageInfo232; -typedef VkResolveImageInfo232 VkResolveImageInfo2KHR32; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + VkComponentTypeNV AType; + VkComponentTypeNV BType; + VkComponentTypeNV CType; + VkComponentTypeNV DType; + VkScopeNV scope; +} VkCooperativeMatrixPropertiesNV32;

-typedef struct VkCoarseSampleOrderCustomNV32 +typedef struct VkCooperativeVectorPropertiesNV32 { - VkShadingRatePaletteEntryNV shadingRate; - uint32_t sampleCount; - uint32_t sampleLocationCount; - PTR32 pSampleLocations; -} VkCoarseSampleOrderCustomNV32; + VkStructureType sType; + PTR32 pNext; + VkComponentTypeKHR inputType; + VkComponentTypeKHR inputInterpretation; + VkComponentTypeKHR matrixInterpretation; + VkComponentTypeKHR biasInterpretation; + VkComponentTypeKHR resultType; + VkBool32 transpose; +} VkCooperativeVectorPropertiesNV32;

-typedef struct VkDepthBiasRepresentationInfoEXT32 +typedef struct VkCopyAccelerationStructureInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkDepthBiasRepresentationEXT depthBiasRepresentation; - VkBool32 depthBiasExact; -} VkDepthBiasRepresentationInfoEXT32; + VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src; + VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst; + VkCopyAccelerationStructureModeKHR mode; +} VkCopyAccelerationStructureInfoKHR32;

-typedef struct VkDepthBiasInfoEXT32 +typedef struct VkCopyAccelerationStructureToMemoryInfoKHR32 { VkStructureType sType; PTR32 pNext; - float depthBiasConstantFactor; - float depthBiasClamp; - float depthBiasSlopeFactor; -} VkDepthBiasInfoEXT32; + VkAccelerationStructureKHR DECLSPEC_ALIGN(8) src; + VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst; + VkCopyAccelerationStructureModeKHR mode; +} VkCopyAccelerationStructureToMemoryInfoKHR32;

-typedef struct VkSetDescriptorBufferOffsetsInfoEXT32 +typedef struct VkCopyBufferInfo232 { VkStructureType sType; PTR32 pNext; - VkShaderStageFlags stageFlags; - VkPipelineLayout DECLSPEC_ALIGN(8) layout; - uint32_t firstSet; - uint32_t setCount; - PTR32 pBufferIndices; - PTR32 pOffsets; -} VkSetDescriptorBufferOffsetsInfoEXT32; + VkBuffer DECLSPEC_ALIGN(8) srcBuffer; + VkBuffer DECLSPEC_ALIGN(8) dstBuffer; + uint32_t regionCount; + PTR32 pRegions; +} VkCopyBufferInfo232; +typedef VkCopyBufferInfo232 VkCopyBufferInfo2KHR32;

-typedef struct VkPerformanceMarkerInfoINTEL32 +typedef struct VkCopyBufferToImageInfo232 { VkStructureType sType; PTR32 pNext; - uint64_t DECLSPEC_ALIGN(8) marker; -} VkPerformanceMarkerInfoINTEL32; + VkBuffer DECLSPEC_ALIGN(8) srcBuffer; + VkImage DECLSPEC_ALIGN(8) dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + PTR32 pRegions; +} VkCopyBufferToImageInfo232; +typedef VkCopyBufferToImageInfo232 VkCopyBufferToImageInfo2KHR32;

-typedef struct VkPerformanceOverrideInfoINTEL32 +typedef struct VkCopyCommandTransformInfoQCOM32 { VkStructureType sType; PTR32 pNext; - VkPerformanceOverrideTypeINTEL type; - VkBool32 enable; - uint64_t DECLSPEC_ALIGN(8) parameter; -} VkPerformanceOverrideInfoINTEL32; + VkSurfaceTransformFlagBitsKHR transform; +} VkCopyCommandTransformInfoQCOM32;

-typedef struct VkPerformanceStreamMarkerInfoINTEL32 +typedef struct VkCopyDescriptorSet32 { VkStructureType sType; PTR32 pNext; - uint32_t marker; -} VkPerformanceStreamMarkerInfoINTEL32; + VkDescriptorSet DECLSPEC_ALIGN(8) srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet DECLSPEC_ALIGN(8) dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; +} VkCopyDescriptorSet32;

-typedef struct VkVertexInputBindingDescription2EXT32 +typedef struct VkCopyImageInfo232 { VkStructureType sType; PTR32 pNext; - uint32_t binding; - uint32_t stride; - VkVertexInputRate inputRate; - uint32_t divisor; -} VkVertexInputBindingDescription2EXT32; + VkImage DECLSPEC_ALIGN(8) srcImage; + VkImageLayout srcImageLayout; + VkImage DECLSPEC_ALIGN(8) dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + PTR32 pRegions; +} VkCopyImageInfo232; +typedef VkCopyImageInfo232 VkCopyImageInfo2KHR32;

-typedef struct VkVertexInputAttributeDescription2EXT32 +typedef struct VkCopyImageToBufferInfo232 { VkStructureType sType; PTR32 pNext; - uint32_t location; - uint32_t binding; - VkFormat format; - uint32_t offset; -} VkVertexInputAttributeDescription2EXT32; - -typedef struct VkShadingRatePaletteNV32 -{ - uint32_t shadingRatePaletteEntryCount; - PTR32 pShadingRatePaletteEntries; -} VkShadingRatePaletteNV32; + VkImage DECLSPEC_ALIGN(8) srcImage; + VkImageLayout srcImageLayout; + VkBuffer DECLSPEC_ALIGN(8) dstBuffer; + uint32_t regionCount; + PTR32 pRegions; +} VkCopyImageToBufferInfo232; +typedef VkCopyImageToBufferInfo232 VkCopyImageToBufferInfo2KHR32;

typedef struct VkCopyImageToImageInfo32 { @@ -2104,19 +2373,6 @@ typedef struct VkCopyImageToImageInfo32 } VkCopyImageToImageInfo32; typedef VkCopyImageToImageInfo32 VkCopyImageToImageInfoEXT32;

-typedef struct VkImageToMemoryCopy32 -{ - VkStructureType sType; - PTR32 pNext; - PTR32 pHostPointer; - uint32_t memoryRowLength; - uint32_t memoryImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkImageToMemoryCopy32; -typedef VkImageToMemoryCopy32 VkImageToMemoryCopyEXT32; - typedef struct VkCopyImageToMemoryInfo32 { VkStructureType sType; @@ -2129,18 +2385,14 @@ typedef struct VkCopyImageToMemoryInfo32 } VkCopyImageToMemoryInfo32; typedef VkCopyImageToMemoryInfo32 VkCopyImageToMemoryInfoEXT32;

-typedef struct VkMemoryToImageCopy32 +typedef struct VkCopyMemoryToAccelerationStructureInfoKHR32 { VkStructureType sType; PTR32 pNext; - PTR32 pHostPointer; - uint32_t memoryRowLength; - uint32_t memoryImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkMemoryToImageCopy32; -typedef VkMemoryToImageCopy32 VkMemoryToImageCopyEXT32; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src; + VkAccelerationStructureKHR DECLSPEC_ALIGN(8) dst; + VkCopyAccelerationStructureModeKHR mode; +} VkCopyMemoryToAccelerationStructureInfoKHR32;

typedef struct VkCopyMemoryToImageInfo32 { @@ -2154,459 +2406,370 @@ typedef struct VkCopyMemoryToImageInfo32 } VkCopyMemoryToImageInfo32; typedef VkCopyMemoryToImageInfo32 VkCopyMemoryToImageInfoEXT32;

-typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT32 -{ - VkStructureType sType; - PTR32 pNext; - PTR32 opaqueCaptureDescriptorData; -} VkOpaqueCaptureDescriptorDataCreateInfoEXT32; - -typedef struct VkAccelerationStructureMotionInfoNV32 -{ - VkStructureType sType; - PTR32 pNext; - uint32_t maxInstances; - VkAccelerationStructureMotionInfoFlagsNV flags; -} VkAccelerationStructureMotionInfoNV32; - -typedef struct VkAccelerationStructureCreateInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - VkAccelerationStructureCreateFlagsKHR createFlags; - VkBuffer DECLSPEC_ALIGN(8) buffer; - VkDeviceSize DECLSPEC_ALIGN(8) offset; - VkDeviceSize DECLSPEC_ALIGN(8) size; - VkAccelerationStructureTypeKHR type; - VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress; -} VkAccelerationStructureCreateInfoKHR32; - -typedef struct VkAccelerationStructureCreateInfoNV32 -{ - VkStructureType sType; - PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) compactedSize; - VkAccelerationStructureInfoNV32 info; -} VkAccelerationStructureCreateInfoNV32; - -typedef struct VkVideoDecodeUsageInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - VkVideoDecodeUsageFlagsKHR videoUsageHints; -} VkVideoDecodeUsageInfoKHR32; - -typedef struct VkVideoDecodeH264ProfileInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - StdVideoH264ProfileIdc stdProfileIdc; - VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout; -} VkVideoDecodeH264ProfileInfoKHR32; - -typedef struct VkVideoDecodeVP9ProfileInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - StdVideoVP9Profile stdProfile; -} VkVideoDecodeVP9ProfileInfoKHR32; - -typedef struct VkVideoDecodeAV1ProfileInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - StdVideoAV1Profile stdProfile; - VkBool32 filmGrainSupport; -} VkVideoDecodeAV1ProfileInfoKHR32; - -typedef struct VkVideoEncodeUsageInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - VkVideoEncodeUsageFlagsKHR videoUsageHints; - VkVideoEncodeContentFlagsKHR videoContentHints; - VkVideoEncodeTuningModeKHR tuningMode; -} VkVideoEncodeUsageInfoKHR32; - -typedef struct VkVideoEncodeH264ProfileInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - StdVideoH264ProfileIdc stdProfileIdc; -} VkVideoEncodeH264ProfileInfoKHR32; - -typedef struct VkVideoEncodeAV1ProfileInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - StdVideoAV1Profile stdProfile; -} VkVideoEncodeAV1ProfileInfoKHR32; - -typedef struct VkVideoProfileInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - VkVideoCodecOperationFlagBitsKHR videoCodecOperation; - VkVideoChromaSubsamplingFlagsKHR chromaSubsampling; - VkVideoComponentBitDepthFlagsKHR lumaBitDepth; - VkVideoComponentBitDepthFlagsKHR chromaBitDepth; -} VkVideoProfileInfoKHR32; - -typedef struct VkDedicatedAllocationBufferCreateInfoNV32 +typedef struct VkCopyMemoryToMicromapInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 dedicatedAllocation; -} VkDedicatedAllocationBufferCreateInfoNV32; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) src; + VkMicromapEXT DECLSPEC_ALIGN(8) dst; + VkCopyMicromapModeEXT mode; +} VkCopyMemoryToMicromapInfoEXT32;

-typedef struct VkExternalMemoryBufferCreateInfo32 +typedef struct VkCopyMicromapInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExternalMemoryBufferCreateInfo32; -typedef VkExternalMemoryBufferCreateInfo32 VkExternalMemoryBufferCreateInfoKHR32; + VkMicromapEXT DECLSPEC_ALIGN(8) src; + VkMicromapEXT DECLSPEC_ALIGN(8) dst; + VkCopyMicromapModeEXT mode; +} VkCopyMicromapInfoEXT32;

-typedef struct VkBufferOpaqueCaptureAddressCreateInfo32 +typedef struct VkCopyMicromapToMemoryInfoEXT32 { VkStructureType sType; PTR32 pNext; - uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress; -} VkBufferOpaqueCaptureAddressCreateInfo32; -typedef VkBufferOpaqueCaptureAddressCreateInfo32 VkBufferOpaqueCaptureAddressCreateInfoKHR32; + VkMicromapEXT DECLSPEC_ALIGN(8) src; + VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) dst; + VkCopyMicromapModeEXT mode; +} VkCopyMicromapToMemoryInfoEXT32;

-typedef struct VkBufferDeviceAddressCreateInfoEXT32 +typedef struct VkCopyTensorInfoARM32 { VkStructureType sType; PTR32 pNext; - VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress; -} VkBufferDeviceAddressCreateInfoEXT32; + VkTensorARM DECLSPEC_ALIGN(8) srcTensor; + VkTensorARM DECLSPEC_ALIGN(8) dstTensor; + uint32_t regionCount; + PTR32 pRegions; +} VkCopyTensorInfoARM32;

-typedef struct VkVideoProfileListInfoKHR32 +typedef struct VkCuFunctionCreateInfoNVX32 { VkStructureType sType; PTR32 pNext; - uint32_t profileCount; - PTR32 pProfiles; -} VkVideoProfileListInfoKHR32; + VkCuModuleNVX DECLSPEC_ALIGN(8) module; + PTR32 pName; +} VkCuFunctionCreateInfoNVX32;

-typedef struct VkBufferCreateInfo32 +typedef struct VkCuLaunchInfoNVX32 { VkStructureType sType; PTR32 pNext; - VkBufferCreateFlags flags; - VkDeviceSize DECLSPEC_ALIGN(8) size; - VkBufferUsageFlags usage; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - PTR32 pQueueFamilyIndices; -} VkBufferCreateInfo32; + VkCuFunctionNVX DECLSPEC_ALIGN(8) function; + uint32_t gridDimX; + uint32_t gridDimY; + uint32_t gridDimZ; + uint32_t blockDimX; + uint32_t blockDimY; + uint32_t blockDimZ; + uint32_t sharedMemBytes; + PTR32 paramCount; + PTR32 pParams; + PTR32 extraCount; + PTR32 pExtras; +} VkCuLaunchInfoNVX32;

-typedef struct VkBufferViewCreateInfo32 +typedef struct VkCuModuleCreateInfoNVX32 { VkStructureType sType; PTR32 pNext; - VkBufferViewCreateFlags flags; - VkBuffer DECLSPEC_ALIGN(8) buffer; - VkFormat format; - VkDeviceSize DECLSPEC_ALIGN(8) offset; - VkDeviceSize DECLSPEC_ALIGN(8) range; -} VkBufferViewCreateInfo32; + PTR32 dataSize; + PTR32 pData; +} VkCuModuleCreateInfoNVX32;

-typedef struct VkDataGraphProcessingEngineCreateInfoARM32 +typedef struct VkCuModuleTexturingModeCreateInfoNVX32 { VkStructureType sType; PTR32 pNext; - uint32_t processingEngineCount; - PTR32 pProcessingEngines; -} VkDataGraphProcessingEngineCreateInfoARM32; + VkBool32 use64bitTexturing; +} VkCuModuleTexturingModeCreateInfoNVX32;

-typedef struct VkCommandPoolCreateInfo32 +typedef struct VkDataGraphPipelineCompilerControlCreateInfoARM32 { VkStructureType sType; PTR32 pNext; - VkCommandPoolCreateFlags flags; - uint32_t queueFamilyIndex; -} VkCommandPoolCreateInfo32; - -typedef struct VkPipelineCreationFeedback32 -{ - VkPipelineCreationFeedbackFlags flags; - uint64_t DECLSPEC_ALIGN(8) duration; -} VkPipelineCreationFeedback32; -typedef VkPipelineCreationFeedback32 VkPipelineCreationFeedbackEXT32; - -typedef struct VkSpecializationMapEntry32 -{ - uint32_t constantID; - uint32_t offset; - PTR32 size; -} VkSpecializationMapEntry32; + PTR32 pVendorOptions; +} VkDataGraphPipelineCompilerControlCreateInfoARM32;

-typedef struct VkSpecializationInfo32 +typedef struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 { - uint32_t mapEntryCount; - PTR32 pMapEntries; - PTR32 dataSize; - PTR32 pData; -} VkSpecializationInfo32; + VkStructureType sType; + PTR32 pNext; + uint32_t dimension; + uint32_t zeroCount; + uint32_t groupSize; +} VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32;

-typedef struct VkShaderModuleCreateInfo32 +typedef struct VkDataGraphPipelineCreateInfoARM32 { VkStructureType sType; PTR32 pNext; - VkShaderModuleCreateFlags flags; - PTR32 codeSize; - PTR32 pCode; -} VkShaderModuleCreateInfo32; + VkPipelineCreateFlags2KHR flags; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t resourceInfoCount; + PTR32 pResourceInfos; +} VkDataGraphPipelineCreateInfoARM32;

-typedef struct VkShaderModuleValidationCacheCreateInfoEXT32 +typedef struct VkDataGraphPipelineDispatchInfoARM32 { VkStructureType sType; PTR32 pNext; - VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache; -} VkShaderModuleValidationCacheCreateInfoEXT32; + VkDataGraphPipelineDispatchFlagsARM DECLSPEC_ALIGN(8) flags; +} VkDataGraphPipelineDispatchInfoARM32;

-typedef struct VkDebugUtilsObjectNameInfoEXT32 +typedef struct VkDataGraphPipelineIdentifierCreateInfoARM32 { VkStructureType sType; PTR32 pNext; - VkObjectType objectType; - uint64_t DECLSPEC_ALIGN(8) objectHandle; - PTR32 pObjectName; -} VkDebugUtilsObjectNameInfoEXT32; + uint32_t identifierSize; + PTR32 pIdentifier; +} VkDataGraphPipelineIdentifierCreateInfoARM32;

-typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 +typedef struct VkDataGraphPipelineInfoARM32 { VkStructureType sType; PTR32 pNext; - uint32_t requiredSubgroupSize; -} VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32; -typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT32; -typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkShaderRequiredSubgroupSizeCreateInfoEXT32; + VkPipeline DECLSPEC_ALIGN(8) dataGraphPipeline; +} VkDataGraphPipelineInfoARM32;

-typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 +typedef struct VkDataGraphPipelinePropertyQueryResultARM32 { VkStructureType sType; PTR32 pNext; - uint32_t identifierSize; - PTR32 pIdentifier; -} VkPipelineShaderStageModuleIdentifierCreateInfoEXT32; + VkDataGraphPipelinePropertyARM property; + VkBool32 isText; + PTR32 dataSize; + PTR32 pData; +} VkDataGraphPipelinePropertyQueryResultARM32;

-typedef struct VkPipelineRobustnessCreateInfo32 +typedef struct VkDataGraphPipelineSessionBindPointRequirementARM32 { VkStructureType sType; PTR32 pNext; - VkPipelineRobustnessBufferBehavior storageBuffers; - VkPipelineRobustnessBufferBehavior uniformBuffers; - VkPipelineRobustnessBufferBehavior vertexInputs; - VkPipelineRobustnessImageBehavior images; -} VkPipelineRobustnessCreateInfo32; -typedef VkPipelineRobustnessCreateInfo32 VkPipelineRobustnessCreateInfoEXT32; + VkDataGraphPipelineSessionBindPointARM bindPoint; + VkDataGraphPipelineSessionBindPointTypeARM bindPointType; + uint32_t numObjects; +} VkDataGraphPipelineSessionBindPointRequirementARM32;

-typedef struct VkPipelineShaderStageCreateInfo32 +typedef struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM32 { VkStructureType sType; PTR32 pNext; - VkPipelineShaderStageCreateFlags flags; - VkShaderStageFlagBits stage; - VkShaderModule DECLSPEC_ALIGN(8) module; - PTR32 pName; - PTR32 pSpecializationInfo; -} VkPipelineShaderStageCreateInfo32; + VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session; +} VkDataGraphPipelineSessionBindPointRequirementsInfoARM32;

-typedef struct VkComputePipelineIndirectBufferInfoNV32 +typedef struct VkDataGraphPipelineSessionCreateInfoARM32 { VkStructureType sType; PTR32 pNext; - VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress; - VkDeviceSize DECLSPEC_ALIGN(8) size; - VkDeviceAddress DECLSPEC_ALIGN(8) pipelineDeviceAddressCaptureReplay; -} VkComputePipelineIndirectBufferInfoNV32; + VkDataGraphPipelineSessionCreateFlagsARM DECLSPEC_ALIGN(8) flags; + VkPipeline DECLSPEC_ALIGN(8) dataGraphPipeline; +} VkDataGraphPipelineSessionCreateInfoARM32;

-typedef struct VkPipelineCreateFlags2CreateInfo32 +typedef struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM32 { VkStructureType sType; PTR32 pNext; - VkPipelineCreateFlags2 DECLSPEC_ALIGN(8) flags; -} VkPipelineCreateFlags2CreateInfo32; -typedef VkPipelineCreateFlags2CreateInfo32 VkPipelineCreateFlags2CreateInfoKHR32; + VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session; + VkDataGraphPipelineSessionBindPointARM bindPoint; + uint32_t objectIndex; +} VkDataGraphPipelineSessionMemoryRequirementsInfoARM32;

-typedef struct VkPipelineBinaryInfoKHR32 +typedef struct VkDataGraphPipelineShaderModuleCreateInfoARM32 { VkStructureType sType; PTR32 pNext; - uint32_t binaryCount; - PTR32 pPipelineBinaries; -} VkPipelineBinaryInfoKHR32; + VkShaderModule DECLSPEC_ALIGN(8) module; + PTR32 pName; + PTR32 pSpecializationInfo; + uint32_t constantCount; + PTR32 pConstants; +} VkDataGraphPipelineShaderModuleCreateInfoARM32;

-typedef struct VkPipelineCreationFeedbackCreateInfo32 +typedef struct VkDataGraphProcessingEngineCreateInfoARM32 { VkStructureType sType; PTR32 pNext; - PTR32 pPipelineCreationFeedback; - uint32_t pipelineStageCreationFeedbackCount; - PTR32 pPipelineStageCreationFeedbacks; -} VkPipelineCreationFeedbackCreateInfo32; -typedef VkPipelineCreationFeedbackCreateInfo32 VkPipelineCreationFeedbackCreateInfoEXT32; + uint32_t processingEngineCount; + PTR32 pProcessingEngines; +} VkDataGraphProcessingEngineCreateInfoARM32;

-typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI32 +typedef struct VkDebugMarkerMarkerInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkRenderPass DECLSPEC_ALIGN(8) renderPass; - uint32_t subpass; -} VkSubpassShadingPipelineCreateInfoHUAWEI32; + PTR32 pMarkerName; + float color[4]; +} VkDebugMarkerMarkerInfoEXT32;

-typedef struct VkPipelineCompilerControlCreateInfoAMD32 +typedef struct VkDebugMarkerObjectNameInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkPipelineCompilerControlFlagsAMD compilerControlFlags; -} VkPipelineCompilerControlCreateInfoAMD32; + VkDebugReportObjectTypeEXT objectType; + uint64_t DECLSPEC_ALIGN(8) object; + PTR32 pObjectName; +} VkDebugMarkerObjectNameInfoEXT32;

-typedef struct VkComputePipelineCreateInfo32 +typedef struct VkDebugMarkerObjectTagInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkPipelineCreateFlags flags; - VkPipelineShaderStageCreateInfo32 DECLSPEC_ALIGN(8) stage; - VkPipelineLayout DECLSPEC_ALIGN(8) layout; - VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle; - int32_t basePipelineIndex; -} VkComputePipelineCreateInfo32; + VkDebugReportObjectTypeEXT objectType; + uint64_t DECLSPEC_ALIGN(8) object; + uint64_t DECLSPEC_ALIGN(8) tagName; + PTR32 tagSize; + PTR32 pTag; +} VkDebugMarkerObjectTagInfoEXT32;

-typedef struct VkCuFunctionCreateInfoNVX32 +typedef struct VkDebugReportCallbackCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkCuModuleNVX DECLSPEC_ALIGN(8) module; - PTR32 pName; -} VkCuFunctionCreateInfoNVX32; + VkDebugReportFlagsEXT flags; + PTR32 pfnCallback; + PTR32 pUserData; +} VkDebugReportCallbackCreateInfoEXT32;

-typedef struct VkCuModuleTexturingModeCreateInfoNVX32 +typedef struct VkDebugUtilsMessengerCallbackDataEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 use64bitTexturing; -} VkCuModuleTexturingModeCreateInfoNVX32; + VkDebugUtilsMessengerCallbackDataFlagsEXT flags; + PTR32 pMessageIdName; + int32_t messageIdNumber; + PTR32 pMessage; + uint32_t queueLabelCount; + PTR32 pQueueLabels; + uint32_t cmdBufLabelCount; + PTR32 pCmdBufLabels; + uint32_t objectCount; + PTR32 pObjects; +} VkDebugUtilsMessengerCallbackDataEXT32;

-typedef struct VkCuModuleCreateInfoNVX32 +typedef struct VkDebugUtilsMessengerCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - PTR32 dataSize; - PTR32 pData; -} VkCuModuleCreateInfoNVX32; + VkDebugUtilsMessengerCreateFlagsEXT flags; + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; + VkDebugUtilsMessageTypeFlagsEXT messageType; + PTR32 pfnUserCallback; + PTR32 pUserData; +} VkDebugUtilsMessengerCreateInfoEXT32;

-typedef struct VkDataGraphPipelineSessionCreateInfoARM32 +typedef struct VkDebugUtilsObjectTagInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkDataGraphPipelineSessionCreateFlagsARM DECLSPEC_ALIGN(8) flags; - VkPipeline DECLSPEC_ALIGN(8) dataGraphPipeline; -} VkDataGraphPipelineSessionCreateInfoARM32; + VkObjectType objectType; + uint64_t DECLSPEC_ALIGN(8) objectHandle; + uint64_t DECLSPEC_ALIGN(8) tagName; + PTR32 tagSize; + PTR32 pTag; +} VkDebugUtilsObjectTagInfoEXT32;

-typedef struct VkTensorDescriptionARM32 +typedef struct VkDecompressMemoryRegionNV32 +{ + VkDeviceAddress DECLSPEC_ALIGN(8) srcAddress; + VkDeviceAddress DECLSPEC_ALIGN(8) dstAddress; + VkDeviceSize DECLSPEC_ALIGN(8) compressedSize; + VkDeviceSize DECLSPEC_ALIGN(8) decompressedSize; + VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethod; +} VkDecompressMemoryRegionNV32; + +typedef struct VkDedicatedAllocationBufferCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkTensorTilingARM tiling; - VkFormat format; - uint32_t dimensionCount; - PTR32 pDimensions; - PTR32 pStrides; - VkTensorUsageFlagsARM DECLSPEC_ALIGN(8) usage; -} VkTensorDescriptionARM32; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationBufferCreateInfoNV32;

-typedef struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 +typedef struct VkDedicatedAllocationImageCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - uint32_t dimension; - uint32_t zeroCount; - uint32_t groupSize; -} VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationImageCreateInfoNV32;

-typedef struct VkDataGraphPipelineConstantARM32 +typedef struct VkDedicatedAllocationMemoryAllocateInfoNV32 { VkStructureType sType; PTR32 pNext; - uint32_t id; - PTR32 pConstantData; -} VkDataGraphPipelineConstantARM32; + VkImage DECLSPEC_ALIGN(8) image; + VkBuffer DECLSPEC_ALIGN(8) buffer; +} VkDedicatedAllocationMemoryAllocateInfoNV32;

-typedef struct VkDataGraphPipelineResourceInfoARM32 +typedef struct VkDependencyInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t descriptorSet; - uint32_t binding; - uint32_t arrayElement; -} VkDataGraphPipelineResourceInfoARM32; + VkDependencyFlags dependencyFlags; + uint32_t memoryBarrierCount; + PTR32 pMemoryBarriers; + uint32_t bufferMemoryBarrierCount; + PTR32 pBufferMemoryBarriers; + uint32_t imageMemoryBarrierCount; + PTR32 pImageMemoryBarriers; +} VkDependencyInfo32; +typedef VkDependencyInfo32 VkDependencyInfoKHR32;

-typedef struct VkDataGraphPipelineCompilerControlCreateInfoARM32 +typedef struct VkDepthBiasInfoEXT32 { VkStructureType sType; PTR32 pNext; - PTR32 pVendorOptions; -} VkDataGraphPipelineCompilerControlCreateInfoARM32; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; +} VkDepthBiasInfoEXT32;

-typedef struct VkDataGraphPipelineShaderModuleCreateInfoARM32 +typedef struct VkDepthBiasRepresentationInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkShaderModule DECLSPEC_ALIGN(8) module; - PTR32 pName; - PTR32 pSpecializationInfo; - uint32_t constantCount; - PTR32 pConstants; -} VkDataGraphPipelineShaderModuleCreateInfoARM32; + VkDepthBiasRepresentationEXT depthBiasRepresentation; + VkBool32 depthBiasExact; +} VkDepthBiasRepresentationInfoEXT32;

-typedef struct VkDataGraphPipelineIdentifierCreateInfoARM32 +typedef struct VkDescriptorBufferBindingInfoEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t identifierSize; - PTR32 pIdentifier; -} VkDataGraphPipelineIdentifierCreateInfoARM32; + VkDeviceAddress DECLSPEC_ALIGN(8) address; + VkBufferUsageFlags usage; +} VkDescriptorBufferBindingInfoEXT32;

-typedef struct VkDataGraphPipelineCreateInfoARM32 +typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32 { VkStructureType sType; PTR32 pNext; - VkPipelineCreateFlags2KHR flags; - VkPipelineLayout DECLSPEC_ALIGN(8) layout; - uint32_t resourceInfoCount; - PTR32 pResourceInfos; -} VkDataGraphPipelineCreateInfoARM32; + VkBuffer DECLSPEC_ALIGN(8) buffer; +} VkDescriptorBufferBindingPushDescriptorBufferHandleEXT32;

-typedef struct VkDebugReportCallbackCreateInfoEXT32 +typedef struct VkDescriptorGetInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkDebugReportFlagsEXT flags; - PTR32 pfnCallback; - PTR32 pUserData; -} VkDebugReportCallbackCreateInfoEXT32; + VkDescriptorType type; + VkDescriptorDataEXT32 DECLSPEC_ALIGN(8) data; +} VkDescriptorGetInfoEXT32;

-typedef struct VkDebugUtilsMessengerCreateInfoEXT32 +typedef struct VkDescriptorGetTensorInfoARM32 { VkStructureType sType; PTR32 pNext; - VkDebugUtilsMessengerCreateFlagsEXT flags; - VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; - VkDebugUtilsMessageTypeFlagsEXT messageType; - PTR32 pfnUserCallback; - PTR32 pUserData; -} VkDebugUtilsMessengerCreateInfoEXT32; + VkTensorViewARM DECLSPEC_ALIGN(8) tensorView; +} VkDescriptorGetTensorInfoARM32;

-typedef struct VkMutableDescriptorTypeListEXT32 +typedef struct VkDescriptorPoolCreateInfo32 { - uint32_t descriptorTypeCount; - PTR32 pDescriptorTypes; -} VkMutableDescriptorTypeListEXT32; -typedef VkMutableDescriptorTypeListEXT32 VkMutableDescriptorTypeListVALVE32; + VkStructureType sType; + PTR32 pNext; + VkDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + PTR32 pPoolSizes; +} VkDescriptorPoolCreateInfo32;

typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo32 { @@ -2616,33 +2779,22 @@ typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo32 } VkDescriptorPoolInlineUniformBlockCreateInfo32; typedef VkDescriptorPoolInlineUniformBlockCreateInfo32 VkDescriptorPoolInlineUniformBlockCreateInfoEXT32;

-typedef struct VkMutableDescriptorTypeCreateInfoEXT32 +typedef struct VkDescriptorSetAllocateInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t mutableDescriptorTypeListCount; - PTR32 pMutableDescriptorTypeLists; -} VkMutableDescriptorTypeCreateInfoEXT32; -typedef VkMutableDescriptorTypeCreateInfoEXT32 VkMutableDescriptorTypeCreateInfoVALVE32; + VkDescriptorPool DECLSPEC_ALIGN(8) descriptorPool; + uint32_t descriptorSetCount; + PTR32 pSetLayouts; +} VkDescriptorSetAllocateInfo32;

-typedef struct VkDescriptorPoolCreateInfo32 +typedef struct VkDescriptorSetBindingReferenceVALVE32 { VkStructureType sType; PTR32 pNext; - VkDescriptorPoolCreateFlags flags; - uint32_t maxSets; - uint32_t poolSizeCount; - PTR32 pPoolSizes; -} VkDescriptorPoolCreateInfo32; - -typedef struct VkDescriptorSetLayoutBinding32 -{ + VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout; uint32_t binding; - VkDescriptorType descriptorType; - uint32_t descriptorCount; - VkShaderStageFlags stageFlags; - PTR32 pImmutableSamplers; -} VkDescriptorSetLayoutBinding32; +} VkDescriptorSetBindingReferenceVALVE32;

typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo32 { @@ -2662,16 +2814,38 @@ typedef struct VkDescriptorSetLayoutCreateInfo32 PTR32 pBindings; } VkDescriptorSetLayoutCreateInfo32;

-typedef struct VkDescriptorUpdateTemplateEntry32 +typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE32 { - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - PTR32 offset; - PTR32 stride; -} VkDescriptorUpdateTemplateEntry32; -typedef VkDescriptorUpdateTemplateEntry32 VkDescriptorUpdateTemplateEntryKHR32; + VkStructureType sType; + PTR32 pNext; + PTR32 descriptorOffset; + uint32_t descriptorSize; +} VkDescriptorSetLayoutHostMappingInfoVALVE32; + +typedef struct VkDescriptorSetLayoutSupport32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 supported; +} VkDescriptorSetLayoutSupport32; +typedef VkDescriptorSetLayoutSupport32 VkDescriptorSetLayoutSupportKHR32; + +typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t descriptorSetCount; + PTR32 pDescriptorCounts; +} VkDescriptorSetVariableDescriptorCountAllocateInfo32; +typedef VkDescriptorSetVariableDescriptorCountAllocateInfo32 VkDescriptorSetVariableDescriptorCountAllocateInfoEXT32; + +typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t maxVariableDescriptorCount; +} VkDescriptorSetVariableDescriptorCountLayoutSupport32; +typedef VkDescriptorSetVariableDescriptorCountLayoutSupport32 VkDescriptorSetVariableDescriptorCountLayoutSupportEXT32;

typedef struct VkDescriptorUpdateTemplateCreateInfo32 { @@ -2688,6036 +2862,5957 @@ typedef struct VkDescriptorUpdateTemplateCreateInfo32 } VkDescriptorUpdateTemplateCreateInfo32; typedef VkDescriptorUpdateTemplateCreateInfo32 VkDescriptorUpdateTemplateCreateInfoKHR32;

-typedef struct VkDeviceQueueGlobalPriorityCreateInfo32 +typedef struct VkDeviceAddressBindingCallbackDataEXT32 { VkStructureType sType; PTR32 pNext; - VkQueueGlobalPriority globalPriority; -} VkDeviceQueueGlobalPriorityCreateInfo32; -typedef VkDeviceQueueGlobalPriorityCreateInfo32 VkDeviceQueueGlobalPriorityCreateInfoKHR32; -typedef VkDeviceQueueGlobalPriorityCreateInfo32 VkDeviceQueueGlobalPriorityCreateInfoEXT32; + VkDeviceAddressBindingFlagsEXT flags; + VkDeviceAddress DECLSPEC_ALIGN(8) baseAddress; + VkDeviceSize DECLSPEC_ALIGN(8) size; + VkDeviceAddressBindingTypeEXT bindingType; +} VkDeviceAddressBindingCallbackDataEXT32; + +typedef struct VkDeviceBufferMemoryRequirements32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 pCreateInfo; +} VkDeviceBufferMemoryRequirements32; +typedef VkDeviceBufferMemoryRequirements32 VkDeviceBufferMemoryRequirementsKHR32; + +typedef struct VkDeviceCreateInfo32 +{ + VkStructureType sType; + PTR32 pNext; + VkDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + PTR32 pQueueCreateInfos; + uint32_t enabledLayerCount; + PTR32 ppEnabledLayerNames; + uint32_t enabledExtensionCount; + PTR32 ppEnabledExtensionNames; + PTR32 pEnabledFeatures; +} VkDeviceCreateInfo32; + +typedef struct VkDeviceDiagnosticsConfigCreateInfoNV32 +{ + VkStructureType sType; + PTR32 pNext; + VkDeviceDiagnosticsConfigFlagsNV flags; +} VkDeviceDiagnosticsConfigCreateInfoNV32; + +typedef struct VkDeviceFaultCountsEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t addressInfoCount; + uint32_t vendorInfoCount; + VkDeviceSize DECLSPEC_ALIGN(8) vendorBinarySize; +} VkDeviceFaultCountsEXT32; + +typedef struct VkDeviceFaultInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + char description[VK_MAX_DESCRIPTION_SIZE]; + PTR32 pAddressInfos; + PTR32 pVendorInfos; + PTR32 pVendorBinaryData; +} VkDeviceFaultInfoEXT32; + +typedef struct VkDeviceGroupBindSparseInfo32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; +} VkDeviceGroupBindSparseInfo32; +typedef VkDeviceGroupBindSparseInfo32 VkDeviceGroupBindSparseInfoKHR32; + +typedef struct VkDeviceGroupCommandBufferBeginInfo32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t deviceMask; +} VkDeviceGroupCommandBufferBeginInfo32; +typedef VkDeviceGroupCommandBufferBeginInfo32 VkDeviceGroupCommandBufferBeginInfoKHR32; + +typedef struct VkDeviceGroupDeviceCreateInfo32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t physicalDeviceCount; + PTR32 pPhysicalDevices; +} VkDeviceGroupDeviceCreateInfo32; +typedef VkDeviceGroupDeviceCreateInfo32 VkDeviceGroupDeviceCreateInfoKHR32; + +typedef struct VkDeviceGroupPresentCapabilitiesKHR32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupPresentCapabilitiesKHR32;

-typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM32 +typedef struct VkDeviceGroupPresentInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t shaderCoreCount; -} VkDeviceQueueShaderCoreControlCreateInfoARM32; + uint32_t swapchainCount; + PTR32 pDeviceMasks; + VkDeviceGroupPresentModeFlagBitsKHR mode; +} VkDeviceGroupPresentInfoKHR32;

-typedef struct VkDeviceQueueCreateInfo32 +typedef struct VkDeviceGroupRenderPassBeginInfo32 { VkStructureType sType; PTR32 pNext; - VkDeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueCount; - PTR32 pQueuePriorities; -} VkDeviceQueueCreateInfo32; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + PTR32 pDeviceRenderAreas; +} VkDeviceGroupRenderPassBeginInfo32; +typedef VkDeviceGroupRenderPassBeginInfo32 VkDeviceGroupRenderPassBeginInfoKHR32;

-typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 +typedef struct VkDeviceGroupSubmitInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 deviceGeneratedCommands; -} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32; + uint32_t waitSemaphoreCount; + PTR32 pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + PTR32 pCommandBufferDeviceMasks; + uint32_t signalSemaphoreCount; + PTR32 pSignalSemaphoreDeviceIndices; +} VkDeviceGroupSubmitInfo32; +typedef VkDeviceGroupSubmitInfo32 VkDeviceGroupSubmitInfoKHR32;

-typedef struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 +typedef struct VkDeviceGroupSwapchainCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 deviceGeneratedCompute; - VkBool32 deviceGeneratedComputePipelines; - VkBool32 deviceGeneratedComputeCaptureReplay; -} VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupSwapchainCreateInfoKHR32;

-typedef struct VkDevicePrivateDataCreateInfo32 +typedef struct VkDeviceImageMemoryRequirements32 { VkStructureType sType; PTR32 pNext; - uint32_t privateDataSlotRequestCount; -} VkDevicePrivateDataCreateInfo32; -typedef VkDevicePrivateDataCreateInfo32 VkDevicePrivateDataCreateInfoEXT32; + PTR32 pCreateInfo; + VkImageAspectFlagBits planeAspect; +} VkDeviceImageMemoryRequirements32; +typedef VkDeviceImageMemoryRequirements32 VkDeviceImageMemoryRequirementsKHR32;

-typedef struct VkPhysicalDevicePrivateDataFeatures32 +typedef struct VkDeviceImageSubresourceInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 privateData; -} VkPhysicalDevicePrivateDataFeatures32; -typedef VkPhysicalDevicePrivateDataFeatures32 VkPhysicalDevicePrivateDataFeaturesEXT32; + PTR32 pCreateInfo; + PTR32 pSubresource; +} VkDeviceImageSubresourceInfo32; +typedef VkDeviceImageSubresourceInfo32 VkDeviceImageSubresourceInfoKHR32;

-typedef struct VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 +typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 clusterAccelerationStructure; -} VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; +} VkDeviceMemoryOpaqueCaptureAddressInfo32; +typedef VkDeviceMemoryOpaqueCaptureAddressInfo32 VkDeviceMemoryOpaqueCaptureAddressInfoKHR32;

-typedef struct VkPhysicalDeviceFeatures232 +typedef struct VkDeviceMemoryOverallocationCreateInfoAMD32 { VkStructureType sType; PTR32 pNext; - VkPhysicalDeviceFeatures features; -} VkPhysicalDeviceFeatures232; -typedef VkPhysicalDeviceFeatures232 VkPhysicalDeviceFeatures2KHR32; + VkMemoryOverallocationBehaviorAMD overallocationBehavior; +} VkDeviceMemoryOverallocationCreateInfoAMD32;

-typedef struct VkPhysicalDeviceVariablePointersFeatures32 +typedef struct VkDevicePipelineBinaryInternalCacheControlKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 variablePointersStorageBuffer; - VkBool32 variablePointers; -} VkPhysicalDeviceVariablePointersFeatures32; -typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointersFeaturesKHR32; -typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeaturesKHR32; -typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeatures32; + VkBool32 disableInternalCache; +} VkDevicePipelineBinaryInternalCacheControlKHR32;

-typedef struct VkPhysicalDeviceMultiviewFeatures32 +typedef struct VkDevicePrivateDataCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 multiview; - VkBool32 multiviewGeometryShader; - VkBool32 multiviewTessellationShader; -} VkPhysicalDeviceMultiviewFeatures32; -typedef VkPhysicalDeviceMultiviewFeatures32 VkPhysicalDeviceMultiviewFeaturesKHR32; + uint32_t privateDataSlotRequestCount; +} VkDevicePrivateDataCreateInfo32; +typedef VkDevicePrivateDataCreateInfo32 VkDevicePrivateDataCreateInfoEXT32;

-typedef struct VkDeviceGroupDeviceCreateInfo32 +typedef struct VkDeviceQueueGlobalPriorityCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t physicalDeviceCount; - PTR32 pPhysicalDevices; -} VkDeviceGroupDeviceCreateInfo32; -typedef VkDeviceGroupDeviceCreateInfo32 VkDeviceGroupDeviceCreateInfoKHR32; + VkQueueGlobalPriority globalPriority; +} VkDeviceQueueGlobalPriorityCreateInfo32; +typedef VkDeviceQueueGlobalPriorityCreateInfo32 VkDeviceQueueGlobalPriorityCreateInfoKHR32; +typedef VkDeviceQueueGlobalPriorityCreateInfo32 VkDeviceQueueGlobalPriorityCreateInfoEXT32;

-typedef struct VkPhysicalDevicePresentIdFeaturesKHR32 +typedef struct VkDeviceQueueInfo232 { VkStructureType sType; PTR32 pNext; - VkBool32 presentId; -} VkPhysicalDevicePresentIdFeaturesKHR32; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueIndex; +} VkDeviceQueueInfo232;

-typedef struct VkPhysicalDevicePresentId2FeaturesKHR32 +typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 presentId2; -} VkPhysicalDevicePresentId2FeaturesKHR32; + uint32_t shaderCoreCount; +} VkDeviceQueueShaderCoreControlCreateInfoARM32;

-typedef struct VkPhysicalDevicePresentWaitFeaturesKHR32 +typedef struct VkDeviceTensorMemoryRequirementsARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 presentWait; -} VkPhysicalDevicePresentWaitFeaturesKHR32; + PTR32 pCreateInfo; +} VkDeviceTensorMemoryRequirementsARM32;

-typedef struct VkPhysicalDevicePresentWait2FeaturesKHR32 +typedef struct VkDispatchTileInfoQCOM32 { VkStructureType sType; PTR32 pNext; - VkBool32 presentWait2; -} VkPhysicalDevicePresentWait2FeaturesKHR32; +} VkDispatchTileInfoQCOM32;

-typedef struct VkPhysicalDevice16BitStorageFeatures32 +typedef struct VkEventCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 storageBuffer16BitAccess; - VkBool32 uniformAndStorageBuffer16BitAccess; - VkBool32 storagePushConstant16; - VkBool32 storageInputOutput16; -} VkPhysicalDevice16BitStorageFeatures32; -typedef VkPhysicalDevice16BitStorageFeatures32 VkPhysicalDevice16BitStorageFeaturesKHR32; + VkEventCreateFlags flags; +} VkEventCreateInfo32;

-typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 +typedef struct VkExportFenceCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderSubgroupExtendedTypes; -} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32; -typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR32; + VkExternalFenceHandleTypeFlags handleTypes; +} VkExportFenceCreateInfo32; +typedef VkExportFenceCreateInfo32 VkExportFenceCreateInfoKHR32;

-typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures32 +typedef struct VkExportMemoryAllocateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 samplerYcbcrConversion; -} VkPhysicalDeviceSamplerYcbcrConversionFeatures32; -typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures32 VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR32; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExportMemoryAllocateInfo32; +typedef VkExportMemoryAllocateInfo32 VkExportMemoryAllocateInfoKHR32;

-typedef struct VkPhysicalDeviceProtectedMemoryFeatures32 +typedef struct VkExportMemoryWin32HandleInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 protectedMemory; -} VkPhysicalDeviceProtectedMemoryFeatures32; + PTR32 pAttributes; + DWORD dwAccess; + LPCWSTR name; +} VkExportMemoryWin32HandleInfoKHR32;

-typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 +typedef struct VkExportSemaphoreCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 advancedBlendCoherentOperations; -} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32; + VkExternalSemaphoreHandleTypeFlags handleTypes; +} VkExportSemaphoreCreateInfo32; +typedef VkExportSemaphoreCreateInfo32 VkExportSemaphoreCreateInfoKHR32;

-typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT32 +typedef struct VkExternalBufferProperties32 { VkStructureType sType; PTR32 pNext; - VkBool32 multiDraw; -} VkPhysicalDeviceMultiDrawFeaturesEXT32; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalBufferProperties32; +typedef VkExternalBufferProperties32 VkExternalBufferPropertiesKHR32;

-typedef struct VkPhysicalDeviceInlineUniformBlockFeatures32 +typedef struct VkExternalFenceProperties32 { VkStructureType sType; PTR32 pNext; - VkBool32 inlineUniformBlock; - VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; -} VkPhysicalDeviceInlineUniformBlockFeatures32; -typedef VkPhysicalDeviceInlineUniformBlockFeatures32 VkPhysicalDeviceInlineUniformBlockFeaturesEXT32; + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlags compatibleHandleTypes; + VkExternalFenceFeatureFlags externalFenceFeatures; +} VkExternalFenceProperties32; +typedef VkExternalFenceProperties32 VkExternalFencePropertiesKHR32;

-typedef struct VkPhysicalDeviceMaintenance4Features32 +typedef struct VkExternalImageFormatProperties32 { VkStructureType sType; PTR32 pNext; - VkBool32 maintenance4; -} VkPhysicalDeviceMaintenance4Features32; -typedef VkPhysicalDeviceMaintenance4Features32 VkPhysicalDeviceMaintenance4FeaturesKHR32; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalImageFormatProperties32; +typedef VkExternalImageFormatProperties32 VkExternalImageFormatPropertiesKHR32;

-typedef struct VkPhysicalDeviceMaintenance5Features32 +typedef struct VkExternalMemoryAcquireUnmodifiedEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 maintenance5; -} VkPhysicalDeviceMaintenance5Features32; -typedef VkPhysicalDeviceMaintenance5Features32 VkPhysicalDeviceMaintenance5FeaturesKHR32; + VkBool32 acquireUnmodifiedMemory; +} VkExternalMemoryAcquireUnmodifiedEXT32;

-typedef struct VkPhysicalDeviceMaintenance6Features32 +typedef struct VkExternalMemoryBufferCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 maintenance6; -} VkPhysicalDeviceMaintenance6Features32; -typedef VkPhysicalDeviceMaintenance6Features32 VkPhysicalDeviceMaintenance6FeaturesKHR32; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryBufferCreateInfo32; +typedef VkExternalMemoryBufferCreateInfo32 VkExternalMemoryBufferCreateInfoKHR32;

-typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR32 +typedef struct VkExternalMemoryImageCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 maintenance8; -} VkPhysicalDeviceMaintenance8FeaturesKHR32; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryImageCreateInfo32; +typedef VkExternalMemoryImageCreateInfo32 VkExternalMemoryImageCreateInfoKHR32;

-typedef struct VkPhysicalDeviceMaintenance9FeaturesKHR32 +typedef struct VkExternalMemoryTensorCreateInfoARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 maintenance9; -} VkPhysicalDeviceMaintenance9FeaturesKHR32; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryTensorCreateInfoARM32;

-typedef struct VkPhysicalDeviceShaderDrawParametersFeatures32 +typedef struct VkExternalSemaphoreProperties32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderDrawParameters; -} VkPhysicalDeviceShaderDrawParametersFeatures32; -typedef VkPhysicalDeviceShaderDrawParametersFeatures32 VkPhysicalDeviceShaderDrawParameterFeatures32; + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; +} VkExternalSemaphoreProperties32; +typedef VkExternalSemaphoreProperties32 VkExternalSemaphorePropertiesKHR32;

-typedef struct VkPhysicalDeviceShaderFloat16Int8Features32 +typedef struct VkExternalTensorPropertiesARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderFloat16; - VkBool32 shaderInt8; -} VkPhysicalDeviceShaderFloat16Int8Features32; -typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceShaderFloat16Int8FeaturesKHR32; -typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceFloat16Int8FeaturesKHR32; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalTensorPropertiesARM32;

-typedef struct VkPhysicalDeviceHostQueryResetFeatures32 +typedef struct VkFenceCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 hostQueryReset; -} VkPhysicalDeviceHostQueryResetFeatures32; -typedef VkPhysicalDeviceHostQueryResetFeatures32 VkPhysicalDeviceHostQueryResetFeaturesEXT32; + VkFenceCreateFlags flags; +} VkFenceCreateInfo32;

-typedef struct VkPhysicalDeviceGlobalPriorityQueryFeatures32 +typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 globalPriorityQuery; -} VkPhysicalDeviceGlobalPriorityQueryFeatures32; -typedef VkPhysicalDeviceGlobalPriorityQueryFeatures32 VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32; -typedef VkPhysicalDeviceGlobalPriorityQueryFeatures32 VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT32; + VkBool32 filterCubic; + VkBool32 filterCubicMinmax; +} VkFilterCubicImageViewImageFormatPropertiesEXT32;

-typedef struct VkPhysicalDeviceDescriptorIndexingFeatures32 +typedef struct VkFormatProperties232 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderInputAttachmentArrayDynamicIndexing; - VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; - VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; - VkBool32 shaderUniformBufferArrayNonUniformIndexing; - VkBool32 shaderSampledImageArrayNonUniformIndexing; - VkBool32 shaderStorageBufferArrayNonUniformIndexing; - VkBool32 shaderStorageImageArrayNonUniformIndexing; - VkBool32 shaderInputAttachmentArrayNonUniformIndexing; - VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; - VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; - VkBool32 descriptorBindingUniformBufferUpdateAfterBind; - VkBool32 descriptorBindingSampledImageUpdateAfterBind; - VkBool32 descriptorBindingStorageImageUpdateAfterBind; - VkBool32 descriptorBindingStorageBufferUpdateAfterBind; - VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingUpdateUnusedWhilePending; - VkBool32 descriptorBindingPartiallyBound; - VkBool32 descriptorBindingVariableDescriptorCount; - VkBool32 runtimeDescriptorArray; -} VkPhysicalDeviceDescriptorIndexingFeatures32; -typedef VkPhysicalDeviceDescriptorIndexingFeatures32 VkPhysicalDeviceDescriptorIndexingFeaturesEXT32; + VkFormatProperties formatProperties; +} VkFormatProperties232; +typedef VkFormatProperties232 VkFormatProperties2KHR32;

-typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures32 +typedef struct VkFormatProperties332 { VkStructureType sType; PTR32 pNext; - VkBool32 timelineSemaphore; -} VkPhysicalDeviceTimelineSemaphoreFeatures32; -typedef VkPhysicalDeviceTimelineSemaphoreFeatures32 VkPhysicalDeviceTimelineSemaphoreFeaturesKHR32; + VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingFeatures; + VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingFeatures; + VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) bufferFeatures; +} VkFormatProperties332; +typedef VkFormatProperties332 VkFormatProperties3KHR32;

-typedef struct VkPhysicalDevice8BitStorageFeatures32 +typedef struct VkFragmentShadingRateAttachmentInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 storageBuffer8BitAccess; - VkBool32 uniformAndStorageBuffer8BitAccess; - VkBool32 storagePushConstant8; -} VkPhysicalDevice8BitStorageFeatures32; -typedef VkPhysicalDevice8BitStorageFeatures32 VkPhysicalDevice8BitStorageFeaturesKHR32; + PTR32 pFragmentShadingRateAttachment; + VkExtent2D shadingRateAttachmentTexelSize; +} VkFragmentShadingRateAttachmentInfoKHR32;

-typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT32 +typedef struct VkFrameBoundaryEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 conditionalRendering; - VkBool32 inheritedConditionalRendering; -} VkPhysicalDeviceConditionalRenderingFeaturesEXT32; + VkFrameBoundaryFlagsEXT flags; + uint64_t DECLSPEC_ALIGN(8) frameID; + uint32_t imageCount; + PTR32 pImages; + uint32_t bufferCount; + PTR32 pBuffers; + uint64_t DECLSPEC_ALIGN(8) tagName; + PTR32 tagSize; + PTR32 pTag; +} VkFrameBoundaryEXT32;

-typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures32 +typedef struct VkFrameBoundaryTensorsARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 vulkanMemoryModel; - VkBool32 vulkanMemoryModelDeviceScope; - VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; -} VkPhysicalDeviceVulkanMemoryModelFeatures32; -typedef VkPhysicalDeviceVulkanMemoryModelFeatures32 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR32; + uint32_t tensorCount; + PTR32 pTensors; +} VkFrameBoundaryTensorsARM32;

-typedef struct VkPhysicalDeviceShaderAtomicInt64Features32 +typedef struct VkFramebufferAttachmentsCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderBufferInt64Atomics; - VkBool32 shaderSharedInt64Atomics; -} VkPhysicalDeviceShaderAtomicInt64Features32; -typedef VkPhysicalDeviceShaderAtomicInt64Features32 VkPhysicalDeviceShaderAtomicInt64FeaturesKHR32; + uint32_t attachmentImageInfoCount; + PTR32 pAttachmentImageInfos; +} VkFramebufferAttachmentsCreateInfo32; +typedef VkFramebufferAttachmentsCreateInfo32 VkFramebufferAttachmentsCreateInfoKHR32;

-typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 +typedef struct VkFramebufferCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderBufferFloat32Atomics; - VkBool32 shaderBufferFloat32AtomicAdd; - VkBool32 shaderBufferFloat64Atomics; - VkBool32 shaderBufferFloat64AtomicAdd; - VkBool32 shaderSharedFloat32Atomics; - VkBool32 shaderSharedFloat32AtomicAdd; - VkBool32 shaderSharedFloat64Atomics; - VkBool32 shaderSharedFloat64AtomicAdd; - VkBool32 shaderImageFloat32Atomics; - VkBool32 shaderImageFloat32AtomicAdd; - VkBool32 sparseImageFloat32Atomics; - VkBool32 sparseImageFloat32AtomicAdd; -} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32; + VkFramebufferCreateFlags flags; + VkRenderPass DECLSPEC_ALIGN(8) renderPass; + uint32_t attachmentCount; + PTR32 pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo32;

-typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 +typedef struct VkFramebufferMixedSamplesCombinationNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderBufferFloat16Atomics; - VkBool32 shaderBufferFloat16AtomicAdd; - VkBool32 shaderBufferFloat16AtomicMinMax; - VkBool32 shaderBufferFloat32AtomicMinMax; - VkBool32 shaderBufferFloat64AtomicMinMax; - VkBool32 shaderSharedFloat16Atomics; - VkBool32 shaderSharedFloat16AtomicAdd; - VkBool32 shaderSharedFloat16AtomicMinMax; - VkBool32 shaderSharedFloat32AtomicMinMax; - VkBool32 shaderSharedFloat64AtomicMinMax; - VkBool32 shaderImageFloat32AtomicMinMax; - VkBool32 sparseImageFloat32AtomicMinMax; -} VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32; + VkCoverageReductionModeNV coverageReductionMode; + VkSampleCountFlagBits rasterizationSamples; + VkSampleCountFlags depthStencilSamples; + VkSampleCountFlags colorSamples; +} VkFramebufferMixedSamplesCombinationNV32;

-typedef struct VkPhysicalDeviceVertexAttributeDivisorFeatures32 +typedef struct VkGeneratedCommandsInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 vertexAttributeInstanceRateDivisor; - VkBool32 vertexAttributeInstanceRateZeroDivisor; -} VkPhysicalDeviceVertexAttributeDivisorFeatures32; -typedef VkPhysicalDeviceVertexAttributeDivisorFeatures32 VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR32; -typedef VkPhysicalDeviceVertexAttributeDivisorFeatures32 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32; + VkShaderStageFlags shaderStages; + VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet; + VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout; + VkDeviceAddress DECLSPEC_ALIGN(8) indirectAddress; + VkDeviceSize DECLSPEC_ALIGN(8) indirectAddressSize; + VkDeviceAddress DECLSPEC_ALIGN(8) preprocessAddress; + VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize; + uint32_t maxSequenceCount; + VkDeviceAddress DECLSPEC_ALIGN(8) sequenceCountAddress; + uint32_t maxDrawCount; +} VkGeneratedCommandsInfoEXT32;

-typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT32 +typedef struct VkGeneratedCommandsInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 decodeModeSharedExponent; -} VkPhysicalDeviceASTCDecodeFeaturesEXT32; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline DECLSPEC_ALIGN(8) pipeline; + VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout; + uint32_t streamCount; + PTR32 pStreams; + uint32_t sequencesCount; + VkBuffer DECLSPEC_ALIGN(8) preprocessBuffer; + VkDeviceSize DECLSPEC_ALIGN(8) preprocessOffset; + VkDeviceSize DECLSPEC_ALIGN(8) preprocessSize; + VkBuffer DECLSPEC_ALIGN(8) sequencesCountBuffer; + VkDeviceSize DECLSPEC_ALIGN(8) sequencesCountOffset; + VkBuffer DECLSPEC_ALIGN(8) sequencesIndexBuffer; + VkDeviceSize DECLSPEC_ALIGN(8) sequencesIndexOffset; +} VkGeneratedCommandsInfoNV32;

-typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT32 +typedef struct VkGeneratedCommandsMemoryRequirementsInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 transformFeedback; - VkBool32 geometryStreams; -} VkPhysicalDeviceTransformFeedbackFeaturesEXT32; + VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet; + VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout; + uint32_t maxSequenceCount; + uint32_t maxDrawCount; +} VkGeneratedCommandsMemoryRequirementsInfoEXT32;

-typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 +typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 representativeFragmentTest; -} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline DECLSPEC_ALIGN(8) pipeline; + VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout; + uint32_t maxSequencesCount; +} VkGeneratedCommandsMemoryRequirementsInfoNV32;

-typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV32 +typedef struct VkGeneratedCommandsPipelineInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 exclusiveScissor; -} VkPhysicalDeviceExclusiveScissorFeaturesNV32; + VkPipeline DECLSPEC_ALIGN(8) pipeline; +} VkGeneratedCommandsPipelineInfoEXT32;

-typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV32 +typedef struct VkGeneratedCommandsShaderInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 cornerSampledImage; -} VkPhysicalDeviceCornerSampledImageFeaturesNV32; + uint32_t shaderCount; + PTR32 pShaders; +} VkGeneratedCommandsShaderInfoEXT32;

-typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 +typedef struct VkGetLatencyMarkerInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 computeDerivativeGroupQuads; - VkBool32 computeDerivativeGroupLinear; -} VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32; -typedef VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32; + uint32_t timingCount; + PTR32 pTimings; +} VkGetLatencyMarkerInfoNV32;

-typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV32 +typedef struct VkGraphicsPipelineCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 imageFootprint; -} VkPhysicalDeviceShaderImageFootprintFeaturesNV32; + VkPipelineCreateFlags flags; + uint32_t stageCount; + PTR32 pStages; + PTR32 pVertexInputState; + PTR32 pInputAssemblyState; + PTR32 pTessellationState; + PTR32 pViewportState; + PTR32 pRasterizationState; + PTR32 pMultisampleState; + PTR32 pDepthStencilState; + PTR32 pColorBlendState; + PTR32 pDynamicState; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + VkRenderPass DECLSPEC_ALIGN(8) renderPass; + uint32_t subpass; + VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo32;

-typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 +typedef struct VkGraphicsPipelineLibraryCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 dedicatedAllocationImageAliasing; -} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32; + VkGraphicsPipelineLibraryFlagsEXT flags; +} VkGraphicsPipelineLibraryCreateInfoEXT32;

-typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 +typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 indirectCopy; -} VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32; + uint32_t groupCount; + PTR32 pGroups; + uint32_t pipelineCount; + PTR32 pPipelines; +} VkGraphicsPipelineShaderGroupsCreateInfoNV32;

-typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV32 +typedef struct VkHdrMetadataEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 memoryDecompression; -} VkPhysicalDeviceMemoryDecompressionFeaturesNV32; + VkXYColorEXT displayPrimaryRed; + VkXYColorEXT displayPrimaryGreen; + VkXYColorEXT displayPrimaryBlue; + VkXYColorEXT whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; +} VkHdrMetadataEXT32;

-typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV32 +typedef struct VkHdrVividDynamicMetadataHUAWEI32 { VkStructureType sType; PTR32 pNext; - VkBool32 shadingRateImage; - VkBool32 shadingRateCoarseSampleOrder; -} VkPhysicalDeviceShadingRateImageFeaturesNV32; + PTR32 dynamicMetadataSize; + PTR32 pDynamicMetadata; +} VkHdrVividDynamicMetadataHUAWEI32;

-typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 +typedef struct VkHostImageCopyDevicePerformanceQuery32 { VkStructureType sType; PTR32 pNext; - VkBool32 invocationMask; -} VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32; + VkBool32 optimalDeviceAccess; + VkBool32 identicalMemoryLayout; +} VkHostImageCopyDevicePerformanceQuery32; +typedef VkHostImageCopyDevicePerformanceQuery32 VkHostImageCopyDevicePerformanceQueryEXT32;

-typedef struct VkPhysicalDeviceMeshShaderFeaturesNV32 +typedef struct VkHostImageLayoutTransitionInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 taskShader; - VkBool32 meshShader; -} VkPhysicalDeviceMeshShaderFeaturesNV32; + VkImage DECLSPEC_ALIGN(8) image; + VkImageLayout oldLayout; + VkImageLayout newLayout; + VkImageSubresourceRange subresourceRange; +} VkHostImageLayoutTransitionInfo32; +typedef VkHostImageLayoutTransitionInfo32 VkHostImageLayoutTransitionInfoEXT32;

-typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT32 +typedef struct VkImageAlignmentControlCreateInfoMESA32 { VkStructureType sType; PTR32 pNext; - VkBool32 taskShader; - VkBool32 meshShader; - VkBool32 multiviewMeshShader; - VkBool32 primitiveFragmentShadingRateMeshShader; - VkBool32 meshShaderQueries; -} VkPhysicalDeviceMeshShaderFeaturesEXT32; + uint32_t maximumRequestedAlignment; +} VkImageAlignmentControlCreateInfoMESA32;

-typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR32 +typedef struct VkImageCaptureDescriptorDataInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 accelerationStructure; - VkBool32 accelerationStructureCaptureReplay; - VkBool32 accelerationStructureIndirectBuild; - VkBool32 accelerationStructureHostCommands; - VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind; -} VkPhysicalDeviceAccelerationStructureFeaturesKHR32; + VkImage DECLSPEC_ALIGN(8) image; +} VkImageCaptureDescriptorDataInfoEXT32;

-typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 +typedef struct VkImageCompressionControlEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 rayTracingPipeline; - VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay; - VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed; - VkBool32 rayTracingPipelineTraceRaysIndirect; - VkBool32 rayTraversalPrimitiveCulling; -} VkPhysicalDeviceRayTracingPipelineFeaturesKHR32; + VkImageCompressionFlagsEXT flags; + uint32_t compressionControlPlaneCount; + PTR32 pFixedRateFlags; +} VkImageCompressionControlEXT32;

-typedef struct VkPhysicalDeviceRayQueryFeaturesKHR32 +typedef struct VkImageCompressionPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 rayQuery; -} VkPhysicalDeviceRayQueryFeaturesKHR32; + VkImageCompressionFlagsEXT imageCompressionFlags; + VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags; +} VkImageCompressionPropertiesEXT32;

-typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 +typedef struct VkImageFormatListCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 rayTracingMaintenance1; - VkBool32 rayTracingPipelineTraceRaysIndirect2; -} VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32; + uint32_t viewFormatCount; + PTR32 pViewFormats; +} VkImageFormatListCreateInfo32; +typedef VkImageFormatListCreateInfo32 VkImageFormatListCreateInfoKHR32;

-typedef struct VkDeviceMemoryOverallocationCreateInfoAMD32 +typedef struct VkImageFormatProperties232 { VkStructureType sType; PTR32 pNext; - VkMemoryOverallocationBehaviorAMD overallocationBehavior; -} VkDeviceMemoryOverallocationCreateInfoAMD32; + VkImageFormatProperties32 DECLSPEC_ALIGN(8) imageFormatProperties; +} VkImageFormatProperties232; +typedef VkImageFormatProperties232 VkImageFormatProperties2KHR32;

-typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 +typedef struct VkImageMemoryBarrier32 { VkStructureType sType; PTR32 pNext; - VkBool32 fragmentDensityMap; - VkBool32 fragmentDensityMapDynamic; - VkBool32 fragmentDensityMapNonSubsampledImages; -} VkPhysicalDeviceFragmentDensityMapFeaturesEXT32; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage DECLSPEC_ALIGN(8) image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier32;

-typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 +typedef struct VkImageMemoryRequirementsInfo232 { VkStructureType sType; PTR32 pNext; - VkBool32 fragmentDensityMapDeferred; -} VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32; + VkImage DECLSPEC_ALIGN(8) image; +} VkImageMemoryRequirementsInfo232; +typedef VkImageMemoryRequirementsInfo232 VkImageMemoryRequirementsInfo2KHR32;

-typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 +typedef struct VkImagePlaneMemoryRequirementsInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 fragmentDensityMapOffset; -} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32; -typedef VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32; + VkImageAspectFlagBits planeAspect; +} VkImagePlaneMemoryRequirementsInfo32; +typedef VkImagePlaneMemoryRequirementsInfo32 VkImagePlaneMemoryRequirementsInfoKHR32;

-typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures32 +typedef struct VkImageSparseMemoryRequirementsInfo232 { VkStructureType sType; PTR32 pNext; - VkBool32 scalarBlockLayout; -} VkPhysicalDeviceScalarBlockLayoutFeatures32; -typedef VkPhysicalDeviceScalarBlockLayoutFeatures32 VkPhysicalDeviceScalarBlockLayoutFeaturesEXT32; + VkImage DECLSPEC_ALIGN(8) image; +} VkImageSparseMemoryRequirementsInfo232; +typedef VkImageSparseMemoryRequirementsInfo232 VkImageSparseMemoryRequirementsInfo2KHR32;

-typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 +typedef struct VkImageStencilUsageCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 uniformBufferStandardLayout; -} VkPhysicalDeviceUniformBufferStandardLayoutFeatures32; -typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR32; + VkImageUsageFlags stencilUsage; +} VkImageStencilUsageCreateInfo32; +typedef VkImageStencilUsageCreateInfo32 VkImageStencilUsageCreateInfoEXT32;

-typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT32 +typedef struct VkImageSwapchainCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 depthClipEnable; -} VkPhysicalDeviceDepthClipEnableFeaturesEXT32; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; +} VkImageSwapchainCreateInfoKHR32;

-typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT32 +typedef struct VkImageViewASTCDecodeModeEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 memoryPriority; -} VkPhysicalDeviceMemoryPriorityFeaturesEXT32; + VkFormat decodeMode; +} VkImageViewASTCDecodeModeEXT32;

-typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 +typedef struct VkImageViewAddressPropertiesNVX32 { VkStructureType sType; PTR32 pNext; - VkBool32 pageableDeviceLocalMemory; -} VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32; + VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress; + VkDeviceSize DECLSPEC_ALIGN(8) size; +} VkImageViewAddressPropertiesNVX32;

-typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures32 +typedef struct VkImageViewCaptureDescriptorDataInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 bufferDeviceAddress; - VkBool32 bufferDeviceAddressCaptureReplay; - VkBool32 bufferDeviceAddressMultiDevice; -} VkPhysicalDeviceBufferDeviceAddressFeatures32; -typedef VkPhysicalDeviceBufferDeviceAddressFeatures32 VkPhysicalDeviceBufferDeviceAddressFeaturesKHR32; + VkImageView DECLSPEC_ALIGN(8) imageView; +} VkImageViewCaptureDescriptorDataInfoEXT32;

-typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 +typedef struct VkImageViewCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 bufferDeviceAddress; - VkBool32 bufferDeviceAddressCaptureReplay; - VkBool32 bufferDeviceAddressMultiDevice; -} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32; -typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 VkPhysicalDeviceBufferAddressFeaturesEXT32; + VkImageViewCreateFlags flags; + VkImage DECLSPEC_ALIGN(8) image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} VkImageViewCreateInfo32;

-typedef struct VkPhysicalDeviceImagelessFramebufferFeatures32 +typedef struct VkImageViewHandleInfoNVX32 { VkStructureType sType; PTR32 pNext; - VkBool32 imagelessFramebuffer; -} VkPhysicalDeviceImagelessFramebufferFeatures32; -typedef VkPhysicalDeviceImagelessFramebufferFeatures32 VkPhysicalDeviceImagelessFramebufferFeaturesKHR32; + VkImageView DECLSPEC_ALIGN(8) imageView; + VkDescriptorType descriptorType; + VkSampler DECLSPEC_ALIGN(8) sampler; +} VkImageViewHandleInfoNVX32;

-typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 +typedef struct VkImageViewMinLodCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 textureCompressionASTC_HDR; -} VkPhysicalDeviceTextureCompressionASTCHDRFeatures32; -typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT32; + float minLod; +} VkImageViewMinLodCreateInfoEXT32;

-typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV32 +typedef struct VkImageViewSampleWeightCreateInfoQCOM32 { VkStructureType sType; PTR32 pNext; - VkBool32 cooperativeMatrix; - VkBool32 cooperativeMatrixRobustBufferAccess; -} VkPhysicalDeviceCooperativeMatrixFeaturesNV32; + VkOffset2D filterCenter; + VkExtent2D filterSize; + uint32_t numPhases; +} VkImageViewSampleWeightCreateInfoQCOM32;

-typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 +typedef struct VkImageViewSlicedCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 ycbcrImageArrays; -} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32; + uint32_t sliceOffset; + uint32_t sliceCount; +} VkImageViewSlicedCreateInfoEXT32;

-typedef struct VkPhysicalDevicePresentBarrierFeaturesNV32 +typedef struct VkImageViewUsageCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 presentBarrier; -} VkPhysicalDevicePresentBarrierFeaturesNV32; + VkImageUsageFlags usage; +} VkImageViewUsageCreateInfo32; +typedef VkImageViewUsageCreateInfo32 VkImageViewUsageCreateInfoKHR32;

-typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR32 +typedef struct VkImportMemoryHostPointerInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 performanceCounterQueryPools; - VkBool32 performanceCounterMultipleQueryPools; -} VkPhysicalDevicePerformanceQueryFeaturesKHR32; + VkExternalMemoryHandleTypeFlagBits handleType; + PTR32 pHostPointer; +} VkImportMemoryHostPointerInfoEXT32;

-typedef struct VkPerformanceQueryReservationInfoKHR32 +typedef struct VkImportMemoryWin32HandleInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t maxPerformanceQueriesPerPool; -} VkPerformanceQueryReservationInfoKHR32; + VkExternalMemoryHandleTypeFlagBits handleType; + HANDLE handle; + LPCWSTR name; +} VkImportMemoryWin32HandleInfoKHR32;

-typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV32 +typedef struct VkIndirectCommandsLayoutCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 coverageReductionMode; -} VkPhysicalDeviceCoverageReductionModeFeaturesNV32; + VkIndirectCommandsLayoutUsageFlagsEXT flags; + VkShaderStageFlags shaderStages; + uint32_t indirectStride; + VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout; + uint32_t tokenCount; + PTR32 pTokens; +} VkIndirectCommandsLayoutCreateInfoEXT32;

-typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 +typedef struct VkIndirectCommandsLayoutCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderIntegerFunctions2; -} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32; + VkIndirectCommandsLayoutUsageFlagsNV flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t tokenCount; + PTR32 pTokens; + uint32_t streamCount; + PTR32 pStreamStrides; +} VkIndirectCommandsLayoutCreateInfoNV32;

-typedef struct VkPhysicalDeviceShaderClockFeaturesKHR32 +typedef struct VkIndirectExecutionSetCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderSubgroupClock; - VkBool32 shaderDeviceClock; -} VkPhysicalDeviceShaderClockFeaturesKHR32; + VkIndirectExecutionSetInfoTypeEXT type; + VkIndirectExecutionSetInfoEXT32 info; +} VkIndirectExecutionSetCreateInfoEXT32; + +typedef struct VkInitializePerformanceApiInfoINTEL32 +{ + VkStructureType sType; + PTR32 pNext; + PTR32 pUserData; +} VkInitializePerformanceApiInfoINTEL32;

-typedef struct VkPhysicalDeviceIndexTypeUint8Features32 +typedef struct VkInstanceCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 indexTypeUint8; -} VkPhysicalDeviceIndexTypeUint8Features32; -typedef VkPhysicalDeviceIndexTypeUint8Features32 VkPhysicalDeviceIndexTypeUint8FeaturesKHR32; -typedef VkPhysicalDeviceIndexTypeUint8Features32 VkPhysicalDeviceIndexTypeUint8FeaturesEXT32; + VkInstanceCreateFlags flags; + PTR32 pApplicationInfo; + uint32_t enabledLayerCount; + PTR32 ppEnabledLayerNames; + uint32_t enabledExtensionCount; + PTR32 ppEnabledExtensionNames; +} VkInstanceCreateInfo32;

-typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 +typedef struct VkLatencySleepInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderSMBuiltins; -} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32; + VkSemaphore DECLSPEC_ALIGN(8) signalSemaphore; + uint64_t DECLSPEC_ALIGN(8) value; +} VkLatencySleepInfoNV32;

-typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 +typedef struct VkLatencySleepModeInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 fragmentShaderSampleInterlock; - VkBool32 fragmentShaderPixelInterlock; - VkBool32 fragmentShaderShadingRateInterlock; -} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32; + VkBool32 lowLatencyMode; + VkBool32 lowLatencyBoost; + uint32_t minimumIntervalUs; +} VkLatencySleepModeInfoNV32;

-typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 +typedef struct VkLatencySubmissionPresentIdNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 separateDepthStencilLayouts; -} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32; -typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR32; + uint64_t DECLSPEC_ALIGN(8) presentID; +} VkLatencySubmissionPresentIdNV32;

-typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 +typedef struct VkLatencySurfaceCapabilitiesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 primitiveTopologyListRestart; - VkBool32 primitiveTopologyPatchListRestart; -} VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32; + uint32_t presentModeCount; + PTR32 pPresentModes; +} VkLatencySurfaceCapabilitiesNV32;

-typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 +typedef struct VkLayerSettingsCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 pipelineExecutableInfo; -} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32; + uint32_t settingCount; + PTR32 pSettings; +} VkLayerSettingsCreateInfoEXT32;

-typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 +typedef struct VkMappedMemoryRange32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderDemoteToHelperInvocation; -} VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32; -typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT32; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; + VkDeviceSize DECLSPEC_ALIGN(8) offset; + VkDeviceSize DECLSPEC_ALIGN(8) size; +} VkMappedMemoryRange32;

-typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 +typedef struct VkMemoryAllocateFlagsInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 texelBufferAlignment; -} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32; + VkMemoryAllocateFlags flags; + uint32_t deviceMask; +} VkMemoryAllocateFlagsInfo32; +typedef VkMemoryAllocateFlagsInfo32 VkMemoryAllocateFlagsInfoKHR32;

-typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures32 +typedef struct VkMemoryAllocateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 subgroupSizeControl; - VkBool32 computeFullSubgroups; -} VkPhysicalDeviceSubgroupSizeControlFeatures32; -typedef VkPhysicalDeviceSubgroupSizeControlFeatures32 VkPhysicalDeviceSubgroupSizeControlFeaturesEXT32; + VkDeviceSize DECLSPEC_ALIGN(8) allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocateInfo32;

-typedef struct VkPhysicalDeviceLineRasterizationFeatures32 +typedef struct VkMemoryBarrier32 { VkStructureType sType; PTR32 pNext; - VkBool32 rectangularLines; - VkBool32 bresenhamLines; - VkBool32 smoothLines; - VkBool32 stippledRectangularLines; - VkBool32 stippledBresenhamLines; - VkBool32 stippledSmoothLines; -} VkPhysicalDeviceLineRasterizationFeatures32; -typedef VkPhysicalDeviceLineRasterizationFeatures32 VkPhysicalDeviceLineRasterizationFeaturesKHR32; -typedef VkPhysicalDeviceLineRasterizationFeatures32 VkPhysicalDeviceLineRasterizationFeaturesEXT32; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} VkMemoryBarrier32;

-typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures32 +typedef struct VkMemoryBarrierAccessFlags3KHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 pipelineCreationCacheControl; -} VkPhysicalDevicePipelineCreationCacheControlFeatures32; -typedef VkPhysicalDevicePipelineCreationCacheControlFeatures32 VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT32; + VkAccessFlags3KHR DECLSPEC_ALIGN(8) srcAccessMask3; + VkAccessFlags3KHR DECLSPEC_ALIGN(8) dstAccessMask3; +} VkMemoryBarrierAccessFlags3KHR32;

-typedef struct VkPhysicalDeviceVulkan11Features32 +typedef struct VkMemoryDedicatedAllocateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 storageBuffer16BitAccess; - VkBool32 uniformAndStorageBuffer16BitAccess; - VkBool32 storagePushConstant16; - VkBool32 storageInputOutput16; - VkBool32 multiview; - VkBool32 multiviewGeometryShader; - VkBool32 multiviewTessellationShader; - VkBool32 variablePointersStorageBuffer; - VkBool32 variablePointers; - VkBool32 protectedMemory; - VkBool32 samplerYcbcrConversion; - VkBool32 shaderDrawParameters; -} VkPhysicalDeviceVulkan11Features32; + VkImage DECLSPEC_ALIGN(8) image; + VkBuffer DECLSPEC_ALIGN(8) buffer; +} VkMemoryDedicatedAllocateInfo32; +typedef VkMemoryDedicatedAllocateInfo32 VkMemoryDedicatedAllocateInfoKHR32;

-typedef struct VkPhysicalDeviceVulkan12Features32 +typedef struct VkMemoryDedicatedAllocateInfoTensorARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 samplerMirrorClampToEdge; - VkBool32 drawIndirectCount; - VkBool32 storageBuffer8BitAccess; - VkBool32 uniformAndStorageBuffer8BitAccess; - VkBool32 storagePushConstant8; - VkBool32 shaderBufferInt64Atomics; - VkBool32 shaderSharedInt64Atomics; - VkBool32 shaderFloat16; - VkBool32 shaderInt8; - VkBool32 descriptorIndexing; - VkBool32 shaderInputAttachmentArrayDynamicIndexing; - VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; - VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; - VkBool32 shaderUniformBufferArrayNonUniformIndexing; - VkBool32 shaderSampledImageArrayNonUniformIndexing; - VkBool32 shaderStorageBufferArrayNonUniformIndexing; - VkBool32 shaderStorageImageArrayNonUniformIndexing; - VkBool32 shaderInputAttachmentArrayNonUniformIndexing; - VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; - VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; - VkBool32 descriptorBindingUniformBufferUpdateAfterBind; - VkBool32 descriptorBindingSampledImageUpdateAfterBind; - VkBool32 descriptorBindingStorageImageUpdateAfterBind; - VkBool32 descriptorBindingStorageBufferUpdateAfterBind; - VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingUpdateUnusedWhilePending; - VkBool32 descriptorBindingPartiallyBound; - VkBool32 descriptorBindingVariableDescriptorCount; - VkBool32 runtimeDescriptorArray; - VkBool32 samplerFilterMinmax; - VkBool32 scalarBlockLayout; - VkBool32 imagelessFramebuffer; - VkBool32 uniformBufferStandardLayout; - VkBool32 shaderSubgroupExtendedTypes; - VkBool32 separateDepthStencilLayouts; - VkBool32 hostQueryReset; - VkBool32 timelineSemaphore; - VkBool32 bufferDeviceAddress; - VkBool32 bufferDeviceAddressCaptureReplay; - VkBool32 bufferDeviceAddressMultiDevice; - VkBool32 vulkanMemoryModel; - VkBool32 vulkanMemoryModelDeviceScope; - VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; - VkBool32 shaderOutputViewportIndex; - VkBool32 shaderOutputLayer; - VkBool32 subgroupBroadcastDynamicId; -} VkPhysicalDeviceVulkan12Features32; + VkTensorARM DECLSPEC_ALIGN(8) tensor; +} VkMemoryDedicatedAllocateInfoTensorARM32;

-typedef struct VkPhysicalDeviceVulkan13Features32 +typedef struct VkMemoryDedicatedRequirements32 { VkStructureType sType; PTR32 pNext; - VkBool32 robustImageAccess; - VkBool32 inlineUniformBlock; - VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; - VkBool32 pipelineCreationCacheControl; - VkBool32 privateData; - VkBool32 shaderDemoteToHelperInvocation; - VkBool32 shaderTerminateInvocation; - VkBool32 subgroupSizeControl; - VkBool32 computeFullSubgroups; - VkBool32 synchronization2; - VkBool32 textureCompressionASTC_HDR; - VkBool32 shaderZeroInitializeWorkgroupMemory; - VkBool32 dynamicRendering; - VkBool32 shaderIntegerDotProduct; - VkBool32 maintenance4; -} VkPhysicalDeviceVulkan13Features32; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} VkMemoryDedicatedRequirements32; +typedef VkMemoryDedicatedRequirements32 VkMemoryDedicatedRequirementsKHR32;

-typedef struct VkPhysicalDeviceVulkan14Features32 +typedef struct VkMemoryHostPointerPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 globalPriorityQuery; - VkBool32 shaderSubgroupRotate; - VkBool32 shaderSubgroupRotateClustered; - VkBool32 shaderFloatControls2; - VkBool32 shaderExpectAssume; - VkBool32 rectangularLines; - VkBool32 bresenhamLines; - VkBool32 smoothLines; - VkBool32 stippledRectangularLines; - VkBool32 stippledBresenhamLines; - VkBool32 stippledSmoothLines; - VkBool32 vertexAttributeInstanceRateDivisor; - VkBool32 vertexAttributeInstanceRateZeroDivisor; - VkBool32 indexTypeUint8; - VkBool32 dynamicRenderingLocalRead; - VkBool32 maintenance5; - VkBool32 maintenance6; - VkBool32 pipelineProtectedAccess; - VkBool32 pipelineRobustness; - VkBool32 hostImageCopy; - VkBool32 pushDescriptor; -} VkPhysicalDeviceVulkan14Features32; + uint32_t memoryTypeBits; +} VkMemoryHostPointerPropertiesEXT32;

-typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD32 +typedef struct VkMemoryMapInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 deviceCoherentMemory; -} VkPhysicalDeviceCoherentMemoryFeaturesAMD32; + VkMemoryMapFlags flags; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; + VkDeviceSize DECLSPEC_ALIGN(8) offset; + VkDeviceSize DECLSPEC_ALIGN(8) size; +} VkMemoryMapInfo32; +typedef VkMemoryMapInfo32 VkMemoryMapInfoKHR32;

-typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT32 +typedef struct VkMemoryMapPlacedInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 customBorderColors; - VkBool32 customBorderColorWithoutFormat; -} VkPhysicalDeviceCustomBorderColorFeaturesEXT32; + PTR32 pPlacedAddress; +} VkMemoryMapPlacedInfoEXT32;

-typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 +typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 borderColorSwizzle; - VkBool32 borderColorSwizzleFromImage; -} VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32; + uint64_t DECLSPEC_ALIGN(8) opaqueCaptureAddress; +} VkMemoryOpaqueCaptureAddressAllocateInfo32; +typedef VkMemoryOpaqueCaptureAddressAllocateInfo32 VkMemoryOpaqueCaptureAddressAllocateInfoKHR32;

-typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 +typedef struct VkMemoryPriorityAllocateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 extendedDynamicState; -} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32; + float priority; +} VkMemoryPriorityAllocateInfoEXT32;

-typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 +typedef struct VkMemoryRequirements232 { VkStructureType sType; PTR32 pNext; - VkBool32 extendedDynamicState2; - VkBool32 extendedDynamicState2LogicOp; - VkBool32 extendedDynamicState2PatchControlPoints; -} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32; + VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements; +} VkMemoryRequirements232; +typedef VkMemoryRequirements232 VkMemoryRequirements2KHR32;

-typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 + +typedef struct VkMemoryUnmapInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 extendedDynamicState3TessellationDomainOrigin; - VkBool32 extendedDynamicState3DepthClampEnable; - VkBool32 extendedDynamicState3PolygonMode; - VkBool32 extendedDynamicState3RasterizationSamples; - VkBool32 extendedDynamicState3SampleMask; - VkBool32 extendedDynamicState3AlphaToCoverageEnable; - VkBool32 extendedDynamicState3AlphaToOneEnable; - VkBool32 extendedDynamicState3LogicOpEnable; - VkBool32 extendedDynamicState3ColorBlendEnable; - VkBool32 extendedDynamicState3ColorBlendEquation; - VkBool32 extendedDynamicState3ColorWriteMask; - VkBool32 extendedDynamicState3RasterizationStream; - VkBool32 extendedDynamicState3ConservativeRasterizationMode; - VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize; - VkBool32 extendedDynamicState3DepthClipEnable; - VkBool32 extendedDynamicState3SampleLocationsEnable; - VkBool32 extendedDynamicState3ColorBlendAdvanced; - VkBool32 extendedDynamicState3ProvokingVertexMode; - VkBool32 extendedDynamicState3LineRasterizationMode; - VkBool32 extendedDynamicState3LineStippleEnable; - VkBool32 extendedDynamicState3DepthClipNegativeOneToOne; - VkBool32 extendedDynamicState3ViewportWScalingEnable; - VkBool32 extendedDynamicState3ViewportSwizzle; - VkBool32 extendedDynamicState3CoverageToColorEnable; - VkBool32 extendedDynamicState3CoverageToColorLocation; - VkBool32 extendedDynamicState3CoverageModulationMode; - VkBool32 extendedDynamicState3CoverageModulationTableEnable; - VkBool32 extendedDynamicState3CoverageModulationTable; - VkBool32 extendedDynamicState3CoverageReductionMode; - VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable; - VkBool32 extendedDynamicState3ShadingRateImageEnable; -} VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32; + VkMemoryUnmapFlags flags; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; +} VkMemoryUnmapInfo32; +typedef VkMemoryUnmapInfo32 VkMemoryUnmapInfoKHR32;

-typedef struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 +typedef struct VkMicromapBuildInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 partitionedAccelerationStructure; -} VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32; + VkMicromapTypeEXT type; + VkBuildMicromapFlagsEXT flags; + VkBuildMicromapModeEXT mode; + VkMicromapEXT DECLSPEC_ALIGN(8) dstMicromap; + uint32_t usageCountsCount; + PTR32 pUsageCounts; + PTR32 ppUsageCounts; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) data; + VkDeviceOrHostAddressKHR DECLSPEC_ALIGN(8) scratchData; + VkDeviceOrHostAddressConstKHR DECLSPEC_ALIGN(8) triangleArray; + VkDeviceSize DECLSPEC_ALIGN(8) triangleArrayStride; +} VkMicromapBuildInfoEXT32;

-typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 +typedef struct VkMicromapBuildSizesInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 diagnosticsConfig; -} VkPhysicalDeviceDiagnosticsConfigFeaturesNV32; + VkDeviceSize DECLSPEC_ALIGN(8) micromapSize; + VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize; + VkBool32 discardable; +} VkMicromapBuildSizesInfoEXT32;

-typedef struct VkDeviceDiagnosticsConfigCreateInfoNV32 +typedef struct VkMicromapCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkDeviceDiagnosticsConfigFlagsNV flags; -} VkDeviceDiagnosticsConfigCreateInfoNV32; + VkMicromapCreateFlagsEXT createFlags; + VkBuffer DECLSPEC_ALIGN(8) buffer; + VkDeviceSize DECLSPEC_ALIGN(8) offset; + VkDeviceSize DECLSPEC_ALIGN(8) size; + VkMicromapTypeEXT type; + VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress; +} VkMicromapCreateInfoEXT32;

-typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 +typedef struct VkMicromapVersionInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderZeroInitializeWorkgroupMemory; -} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32; -typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR32; + PTR32 pVersionData; +} VkMicromapVersionInfoEXT32;

-typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 +typedef struct VkMultisamplePropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderSubgroupUniformControlFlow; -} VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32; + VkExtent2D maxSampleLocationGridSize; +} VkMultisamplePropertiesEXT32;

-typedef struct VkPhysicalDeviceRobustness2FeaturesKHR32 +typedef struct VkMultisampledRenderToSingleSampledInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 robustBufferAccess2; - VkBool32 robustImageAccess2; - VkBool32 nullDescriptor; -} VkPhysicalDeviceRobustness2FeaturesKHR32; -typedef VkPhysicalDeviceRobustness2FeaturesKHR32 VkPhysicalDeviceRobustness2FeaturesEXT32; + VkBool32 multisampledRenderToSingleSampledEnable; + VkSampleCountFlagBits rasterizationSamples; +} VkMultisampledRenderToSingleSampledInfoEXT32;

-typedef struct VkPhysicalDeviceImageRobustnessFeatures32 +typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 { VkStructureType sType; PTR32 pNext; - VkBool32 robustImageAccess; -} VkPhysicalDeviceImageRobustnessFeatures32; -typedef VkPhysicalDeviceImageRobustnessFeatures32 VkPhysicalDeviceImageRobustnessFeaturesEXT32; + uint32_t perViewRenderAreaCount; + PTR32 pPerViewRenderAreas; +} VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32;

-typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 +typedef struct VkMutableDescriptorTypeCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 workgroupMemoryExplicitLayout; - VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout; - VkBool32 workgroupMemoryExplicitLayout8BitAccess; - VkBool32 workgroupMemoryExplicitLayout16BitAccess; -} VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32; + uint32_t mutableDescriptorTypeListCount; + PTR32 pMutableDescriptorTypeLists; +} VkMutableDescriptorTypeCreateInfoEXT32; +typedef VkMutableDescriptorTypeCreateInfoEXT32 VkMutableDescriptorTypeCreateInfoVALVE32;

-typedef struct VkPhysicalDevice4444FormatsFeaturesEXT32 +typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 formatA4R4G4B4; - VkBool32 formatA4B4G4R4; -} VkPhysicalDevice4444FormatsFeaturesEXT32; + PTR32 opaqueCaptureDescriptorData; +} VkOpaqueCaptureDescriptorDataCreateInfoEXT32;

-typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 +typedef struct VkOpticalFlowExecuteInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 subpassShading; -} VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32; + VkOpticalFlowExecuteFlagsNV flags; + uint32_t regionCount; + PTR32 pRegions; +} VkOpticalFlowExecuteInfoNV32;

-typedef struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 +typedef struct VkOpticalFlowImageFormatInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 clustercullingShader; - VkBool32 multiviewClusterCullingShader; -} VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32; + VkOpticalFlowUsageFlagsNV usage; +} VkOpticalFlowImageFormatInfoNV32;

-typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 +typedef struct VkOpticalFlowImageFormatPropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderImageInt64Atomics; - VkBool32 sparseImageInt64Atomics; -} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32; + VkFormat format; +} VkOpticalFlowImageFormatPropertiesNV32;

-typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 +typedef struct VkOpticalFlowSessionCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 pipelineFragmentShadingRate; - VkBool32 primitiveFragmentShadingRate; - VkBool32 attachmentFragmentShadingRate; -} VkPhysicalDeviceFragmentShadingRateFeaturesKHR32; + uint32_t width; + uint32_t height; + VkFormat imageFormat; + VkFormat flowVectorFormat; + VkFormat costFormat; + VkOpticalFlowGridSizeFlagsNV outputGridSize; + VkOpticalFlowGridSizeFlagsNV hintGridSize; + VkOpticalFlowPerformanceLevelNV performanceLevel; + VkOpticalFlowSessionCreateFlagsNV flags; +} VkOpticalFlowSessionCreateInfoNV32;

-typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures32 +typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderTerminateInvocation; -} VkPhysicalDeviceShaderTerminateInvocationFeatures32; -typedef VkPhysicalDeviceShaderTerminateInvocationFeatures32 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR32; + uint32_t id; + uint32_t size; + PTR32 pPrivateData; +} VkOpticalFlowSessionCreatePrivateDataInfoNV32;

-typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 +typedef struct VkOutOfBandQueueTypeInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 fragmentShadingRateEnums; - VkBool32 supersampleFragmentShadingRates; - VkBool32 noInvocationFragmentShadingRates; -} VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32; + VkOutOfBandQueueTypeNV queueType; +} VkOutOfBandQueueTypeInfoNV32;

-typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 +typedef struct VkPartitionedAccelerationStructureFlagsNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 image2DViewOf3D; - VkBool32 sampler2DViewOf3D; -} VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32; + VkBool32 enablePartitionTranslation; +} VkPartitionedAccelerationStructureFlagsNV32;

-typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 +typedef struct VkPerTileBeginInfoQCOM32 { VkStructureType sType; PTR32 pNext; - VkBool32 imageSlicedViewOf3D; -} VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32; +} VkPerTileBeginInfoQCOM32;

-typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 +typedef struct VkPerTileEndInfoQCOM32 { VkStructureType sType; PTR32 pNext; - VkBool32 attachmentFeedbackLoopDynamicState; -} VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32; +} VkPerTileEndInfoQCOM32;

-typedef struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 +typedef struct VkPerformanceConfigurationAcquireInfoINTEL32 { VkStructureType sType; PTR32 pNext; - VkBool32 legacyVertexAttributes; -} VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32; + VkPerformanceConfigurationTypeINTEL type; +} VkPerformanceConfigurationAcquireInfoINTEL32;

-typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 +typedef struct VkPerformanceCounterDescriptionKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 mutableDescriptorType; -} VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32; -typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE32; + VkPerformanceCounterDescriptionFlagsKHR flags; + char name[VK_MAX_DESCRIPTION_SIZE]; + char category[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; +} VkPerformanceCounterDescriptionKHR32;

-typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT32 +typedef struct VkPerformanceCounterKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 depthClipControl; -} VkPhysicalDeviceDepthClipControlFeaturesEXT32; + VkPerformanceCounterUnitKHR unit; + VkPerformanceCounterScopeKHR scope; + VkPerformanceCounterStorageKHR storage; + uint8_t uuid[VK_UUID_SIZE]; +} VkPerformanceCounterKHR32;

-typedef struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 +typedef struct VkPerformanceMarkerInfoINTEL32 { VkStructureType sType; PTR32 pNext; - VkBool32 zeroInitializeDeviceMemory; -} VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32; + uint64_t DECLSPEC_ALIGN(8) marker; +} VkPerformanceMarkerInfoINTEL32;

-typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 +typedef struct VkPerformanceOverrideInfoINTEL32 { VkStructureType sType; PTR32 pNext; - VkBool32 deviceGeneratedCommands; - VkBool32 dynamicGeneratedPipelineLayout; -} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32; + VkPerformanceOverrideTypeINTEL type; + VkBool32 enable; + uint64_t DECLSPEC_ALIGN(8) parameter; +} VkPerformanceOverrideInfoINTEL32;

-typedef struct VkPhysicalDeviceDepthClampControlFeaturesEXT32 +typedef struct VkPerformanceQueryReservationInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 depthClampControl; -} VkPhysicalDeviceDepthClampControlFeaturesEXT32; + uint32_t maxPerformanceQueriesPerPool; +} VkPerformanceQueryReservationInfoKHR32;

-typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 +typedef struct VkPerformanceQuerySubmitInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 vertexInputDynamicState; -} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32; + uint32_t counterPassIndex; +} VkPerformanceQuerySubmitInfoKHR32;

-typedef struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 +typedef struct VkPerformanceStreamMarkerInfoINTEL32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderRelaxedExtendedInstruction; -} VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32; + uint32_t marker; +} VkPerformanceStreamMarkerInfoINTEL32;

-typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT32 +typedef struct VkPerformanceValueINTEL32 { - VkStructureType sType; - PTR32 pNext; - VkBool32 colorWriteEnable; -} VkPhysicalDeviceColorWriteEnableFeaturesEXT32; + VkPerformanceValueTypeINTEL type; + VkPerformanceValueDataINTEL32 DECLSPEC_ALIGN(8) data; +} VkPerformanceValueINTEL32;

-typedef struct VkPhysicalDeviceSynchronization2Features32 +typedef struct VkPhysicalDevice16BitStorageFeatures32 { VkStructureType sType; PTR32 pNext; - VkBool32 synchronization2; -} VkPhysicalDeviceSynchronization2Features32; -typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronization2FeaturesKHR32; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeatures32; +typedef VkPhysicalDevice16BitStorageFeatures32 VkPhysicalDevice16BitStorageFeaturesKHR32;

-typedef struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 +typedef struct VkPhysicalDevice4444FormatsFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 unifiedImageLayouts; - VkBool32 unifiedImageLayoutsVideo; -} VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32; + VkBool32 formatA4R4G4B4; + VkBool32 formatA4B4G4R4; +} VkPhysicalDevice4444FormatsFeaturesEXT32;

-typedef struct VkPhysicalDeviceHostImageCopyFeatures32 +typedef struct VkPhysicalDevice8BitStorageFeatures32 { VkStructureType sType; PTR32 pNext; - VkBool32 hostImageCopy; -} VkPhysicalDeviceHostImageCopyFeatures32; -typedef VkPhysicalDeviceHostImageCopyFeatures32 VkPhysicalDeviceHostImageCopyFeaturesEXT32; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; +} VkPhysicalDevice8BitStorageFeatures32; +typedef VkPhysicalDevice8BitStorageFeatures32 VkPhysicalDevice8BitStorageFeaturesKHR32;

-typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 +typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 primitivesGeneratedQuery; - VkBool32 primitivesGeneratedQueryWithRasterizerDiscard; - VkBool32 primitivesGeneratedQueryWithNonZeroStreams; -} VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32; + VkBool32 decodeModeSharedExponent; +} VkPhysicalDeviceASTCDecodeFeaturesEXT32;

-typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT32 +typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 legacyDithering; -} VkPhysicalDeviceLegacyDitheringFeaturesEXT32; + VkBool32 accelerationStructure; + VkBool32 accelerationStructureCaptureReplay; + VkBool32 accelerationStructureIndirectBuild; + VkBool32 accelerationStructureHostCommands; + VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind; +} VkPhysicalDeviceAccelerationStructureFeaturesKHR32;

-typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 +typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 multisampledRenderToSingleSampled; -} VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32; + uint64_t DECLSPEC_ALIGN(8) maxGeometryCount; + uint64_t DECLSPEC_ALIGN(8) maxInstanceCount; + uint64_t DECLSPEC_ALIGN(8) maxPrimitiveCount; + uint32_t maxPerStageDescriptorAccelerationStructures; + uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures; + uint32_t maxDescriptorSetAccelerationStructures; + uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures; + uint32_t minAccelerationStructureScratchOffsetAlignment; +} VkPhysicalDeviceAccelerationStructurePropertiesKHR32;

-typedef struct VkPhysicalDevicePipelineProtectedAccessFeatures32 +typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 pipelineProtectedAccess; -} VkPhysicalDevicePipelineProtectedAccessFeatures32; -typedef VkPhysicalDevicePipelineProtectedAccessFeatures32 VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32; + VkBool32 reportAddressBinding; +} VkPhysicalDeviceAddressBindingReportFeaturesEXT32;

-typedef struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 +typedef struct VkPhysicalDeviceAntiLagFeaturesAMD32 { VkStructureType sType; PTR32 pNext; - VkBool32 videoMaintenance1; -} VkPhysicalDeviceVideoMaintenance1FeaturesKHR32; + VkBool32 antiLag; +} VkPhysicalDeviceAntiLagFeaturesAMD32;

-typedef struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 +typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 videoDecodeVP9; -} VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32; + VkBool32 attachmentFeedbackLoopDynamicState; +} VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32;

-typedef struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 +typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 videoEncodeQuantizationMap; -} VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32; + VkBool32 attachmentFeedbackLoopLayout; +} VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32;

-typedef struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 videoEncodeAV1; -} VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32; + VkBool32 advancedBlendCoherentOperations; +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32;

-typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 inheritedViewportScissor2D; -} VkPhysicalDeviceInheritedViewportScissorFeaturesNV32; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32;

-typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 +typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 ycbcr2plane444Formats; -} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32; + VkBool32 borderColorSwizzle; + VkBool32 borderColorSwizzleFromImage; +} VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32;

-typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT32 +typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures32 { VkStructureType sType; PTR32 pNext; - VkBool32 provokingVertexLast; - VkBool32 transformFeedbackPreservesProvokingVertex; -} VkPhysicalDeviceProvokingVertexFeaturesEXT32; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferDeviceAddressFeatures32; +typedef VkPhysicalDeviceBufferDeviceAddressFeatures32 VkPhysicalDeviceBufferDeviceAddressFeaturesKHR32;

-typedef struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 +typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 videoEncodeIntraRefresh; -} VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32; +typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 VkPhysicalDeviceBufferAddressFeaturesEXT32;

-typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT32 +typedef struct VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 descriptorBuffer; - VkBool32 descriptorBufferCaptureReplay; - VkBool32 descriptorBufferImageLayoutIgnored; - VkBool32 descriptorBufferPushDescriptors; -} VkPhysicalDeviceDescriptorBufferFeaturesEXT32; + VkBool32 clusterAccelerationStructure; +} VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32;

-typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures32 +typedef struct VkPhysicalDeviceClusterAccelerationStructurePropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderIntegerDotProduct; -} VkPhysicalDeviceShaderIntegerDotProductFeatures32; -typedef VkPhysicalDeviceShaderIntegerDotProductFeatures32 VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR32; + uint32_t maxVerticesPerCluster; + uint32_t maxTrianglesPerCluster; + uint32_t clusterScratchByteAlignment; + uint32_t clusterByteAlignment; + uint32_t clusterTemplateByteAlignment; + uint32_t clusterBottomLevelByteAlignment; + uint32_t clusterTemplateBoundsByteAlignment; + uint32_t maxClusterGeometryIndex; +} VkPhysicalDeviceClusterAccelerationStructurePropertiesNV32;

-typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 +typedef struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 { VkStructureType sType; PTR32 pNext; - VkBool32 fragmentShaderBarycentric; -} VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32; -typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV32; + VkBool32 clustercullingShader; + VkBool32 multiviewClusterCullingShader; +} VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32;

-typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 +typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32 { VkStructureType sType; PTR32 pNext; - VkBool32 rayTracingMotionBlur; - VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect; -} VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32; + uint32_t maxWorkGroupCount[3]; + uint32_t maxWorkGroupSize[3]; + uint32_t maxOutputClusterCount; + VkDeviceSize DECLSPEC_ALIGN(8) indirectBufferOffsetAlignment; +} VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32;

-typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV32 +typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD32 { VkStructureType sType; PTR32 pNext; - VkBool32 rayTracingValidation; -} VkPhysicalDeviceRayTracingValidationFeaturesNV32; + VkBool32 deviceCoherentMemory; +} VkPhysicalDeviceCoherentMemoryFeaturesAMD32;

-typedef struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV32 +typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 spheres; - VkBool32 linearSweptSpheres; -} VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV32; + VkBool32 colorWriteEnable; +} VkPhysicalDeviceColorWriteEnableFeaturesEXT32;

-typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 +typedef struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 formatRgba10x6WithoutYCbCrSampler; -} VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32; + VkBool32 commandBufferInheritance; +} VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32;

-typedef struct VkPhysicalDeviceDynamicRenderingFeatures32 +typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 dynamicRendering; -} VkPhysicalDeviceDynamicRenderingFeatures32; -typedef VkPhysicalDeviceDynamicRenderingFeatures32 VkPhysicalDeviceDynamicRenderingFeaturesKHR32; + VkBool32 computeDerivativeGroupQuads; + VkBool32 computeDerivativeGroupLinear; +} VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32; +typedef VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 VkPhysicalDeviceComputeShaderDerivativesFeaturesNV32;

-typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT32 +typedef struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 minLod; -} VkPhysicalDeviceImageViewMinLodFeaturesEXT32; + VkBool32 meshAndTaskShaderDerivatives; +} VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32;

-typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 +typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 rasterizationOrderColorAttachmentAccess; - VkBool32 rasterizationOrderDepthAttachmentAccess; - VkBool32 rasterizationOrderStencilAttachmentAccess; -} VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32; -typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM32; + VkBool32 conditionalRendering; + VkBool32 inheritedConditionalRendering; +} VkPhysicalDeviceConditionalRenderingFeaturesEXT32;

-typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 +typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 linearColorAttachment; -} VkPhysicalDeviceLinearColorAttachmentFeaturesNV32; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + VkBool32 primitiveUnderestimation; + VkBool32 conservativePointAndLineRasterization; + VkBool32 degenerateTrianglesRasterized; + VkBool32 degenerateLinesRasterized; + VkBool32 fullyCoveredFragmentShaderInputVariable; + VkBool32 conservativeRasterizationPostDepthCoverage; +} VkPhysicalDeviceConservativeRasterizationPropertiesEXT32;

-typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 +typedef struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 graphicsPipelineLibrary; -} VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32; + VkBool32 cooperativeMatrixWorkgroupScope; + VkBool32 cooperativeMatrixFlexibleDimensions; + VkBool32 cooperativeMatrixReductions; + VkBool32 cooperativeMatrixConversions; + VkBool32 cooperativeMatrixPerElementOperations; + VkBool32 cooperativeMatrixTensorAddressing; + VkBool32 cooperativeMatrixBlockLoads; +} VkPhysicalDeviceCooperativeMatrix2FeaturesNV32;

-typedef struct VkPhysicalDevicePipelineBinaryFeaturesKHR32 +typedef struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 pipelineBinaries; -} VkPhysicalDevicePipelineBinaryFeaturesKHR32; + uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize; + uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension; + uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory; +} VkPhysicalDeviceCooperativeMatrix2PropertiesNV32;

-typedef struct VkDevicePipelineBinaryInternalCacheControlKHR32 +typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 disableInternalCache; -} VkDevicePipelineBinaryInternalCacheControlKHR32; + VkBool32 cooperativeMatrix; + VkBool32 cooperativeMatrixRobustBufferAccess; +} VkPhysicalDeviceCooperativeMatrixFeaturesKHR32;

-typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 +typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 descriptorSetHostMapping; -} VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32; + VkBool32 cooperativeMatrix; + VkBool32 cooperativeMatrixRobustBufferAccess; +} VkPhysicalDeviceCooperativeMatrixFeaturesNV32;

-typedef struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 +typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 nestedCommandBuffer; - VkBool32 nestedCommandBufferRendering; - VkBool32 nestedCommandBufferSimultaneousUse; -} VkPhysicalDeviceNestedCommandBufferFeaturesEXT32; + VkShaderStageFlags cooperativeMatrixSupportedStages; +} VkPhysicalDeviceCooperativeMatrixPropertiesKHR32;

-typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 +typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderModuleIdentifier; -} VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32; + VkShaderStageFlags cooperativeMatrixSupportedStages; +} VkPhysicalDeviceCooperativeMatrixPropertiesNV32;

-typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT32 +typedef struct VkPhysicalDeviceCooperativeVectorFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 imageCompressionControl; -} VkPhysicalDeviceImageCompressionControlFeaturesEXT32; + VkBool32 cooperativeVector; + VkBool32 cooperativeVectorTraining; +} VkPhysicalDeviceCooperativeVectorFeaturesNV32;

-typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 +typedef struct VkPhysicalDeviceCooperativeVectorPropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 imageCompressionControlSwapchain; -} VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32; + VkShaderStageFlags cooperativeVectorSupportedStages; + VkBool32 cooperativeVectorTrainingFloat16Accumulation; + VkBool32 cooperativeVectorTrainingFloat32Accumulation; + uint32_t maxCooperativeVectorComponents; +} VkPhysicalDeviceCooperativeVectorPropertiesNV32;

-typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 +typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 subpassMergeFeedback; -} VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32; + VkBool32 indirectCopy; +} VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32;

-typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT32 +typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 micromap; - VkBool32 micromapCaptureReplay; - VkBool32 micromapHostCommands; -} VkPhysicalDeviceOpacityMicromapFeaturesEXT32; + VkQueueFlags supportedQueues; +} VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32;

-typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT32 +typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 pipelinePropertiesIdentifier; -} VkPhysicalDevicePipelinePropertiesFeaturesEXT32; + VkBool32 cornerSampledImage; +} VkPhysicalDeviceCornerSampledImageFeaturesNV32;

-typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 +typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderEarlyAndLateFragmentTests; -} VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32; + VkBool32 coverageReductionMode; +} VkPhysicalDeviceCoverageReductionModeFeaturesNV32;

-typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 +typedef struct VkPhysicalDeviceCubicClampFeaturesQCOM32 { VkStructureType sType; PTR32 pNext; - VkBool32 nonSeamlessCubeMap; -} VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32; + VkBool32 cubicRangeClamp; +} VkPhysicalDeviceCubicClampFeaturesQCOM32;

-typedef struct VkPhysicalDevicePipelineRobustnessFeatures32 +typedef struct VkPhysicalDeviceCubicWeightsFeaturesQCOM32 { VkStructureType sType; PTR32 pNext; - VkBool32 pipelineRobustness; -} VkPhysicalDevicePipelineRobustnessFeatures32; -typedef VkPhysicalDevicePipelineRobustnessFeatures32 VkPhysicalDevicePipelineRobustnessFeaturesEXT32; + VkBool32 selectableCubicWeights; +} VkPhysicalDeviceCubicWeightsFeaturesQCOM32;

-typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM32 +typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 textureSampleWeighted; - VkBool32 textureBoxFilter; - VkBool32 textureBlockMatch; -} VkPhysicalDeviceImageProcessingFeaturesQCOM32; + VkBool32 customBorderColors; + VkBool32 customBorderColorWithoutFormat; +} VkPhysicalDeviceCustomBorderColorFeaturesEXT32;

-typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM32 +typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 tileProperties; -} VkPhysicalDeviceTilePropertiesFeaturesQCOM32; + uint32_t maxCustomBorderColorSamplers; +} VkPhysicalDeviceCustomBorderColorPropertiesEXT32;

-typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 +typedef struct VkPhysicalDeviceDataGraphFeaturesARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 attachmentFeedbackLoopLayout; -} VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32; + VkBool32 dataGraph; + VkBool32 dataGraphUpdateAfterBind; + VkBool32 dataGraphSpecializationConstants; + VkBool32 dataGraphDescriptorBuffer; + VkBool32 dataGraphShaderModule; +} VkPhysicalDeviceDataGraphFeaturesARM32;

-typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT32 +typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 reportAddressBinding; -} VkPhysicalDeviceAddressBindingReportFeaturesEXT32; + VkBool32 dedicatedAllocationImageAliasing; +} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32;

-typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV32 +typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 opticalFlow; -} VkPhysicalDeviceOpticalFlowFeaturesNV32; + VkBool32 depthBiasControl; + VkBool32 leastRepresentableValueForceUnormRepresentation; + VkBool32 floatRepresentation; + VkBool32 depthBiasExact; +} VkPhysicalDeviceDepthBiasControlFeaturesEXT32;

-typedef struct VkPhysicalDeviceFaultFeaturesEXT32 +typedef struct VkPhysicalDeviceDepthClampControlFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 deviceFault; - VkBool32 deviceFaultVendorBinary; -} VkPhysicalDeviceFaultFeaturesEXT32; + VkBool32 depthClampControl; +} VkPhysicalDeviceDepthClampControlFeaturesEXT32;

-typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 +typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 pipelineLibraryGroupHandles; -} VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32; + VkBool32 depthClampZeroOne; +} VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32; +typedef VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32;

-typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 +typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderCoreBuiltins; -} VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32; + VkBool32 depthClipControl; +} VkPhysicalDeviceDepthClipControlFeaturesEXT32;

-typedef struct VkPhysicalDeviceFrameBoundaryFeaturesEXT32 +typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 frameBoundary; -} VkPhysicalDeviceFrameBoundaryFeaturesEXT32; + VkBool32 depthClipEnable; +} VkPhysicalDeviceDepthClipEnableFeaturesEXT32;

-typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 +typedef struct VkPhysicalDeviceDepthStencilResolveProperties32 { VkStructureType sType; PTR32 pNext; - VkBool32 dynamicRenderingUnusedAttachments; -} VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; +} VkPhysicalDeviceDepthStencilResolveProperties32; +typedef VkPhysicalDeviceDepthStencilResolveProperties32 VkPhysicalDeviceDepthStencilResolvePropertiesKHR32;

-typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 +typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 swapchainMaintenance1; -} VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32; -typedef VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32; + PTR32 combinedImageSamplerDensityMapDescriptorSize; +} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32;

-typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT32 +typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 depthBiasControl; - VkBool32 leastRepresentableValueForceUnormRepresentation; - VkBool32 floatRepresentation; - VkBool32 depthBiasExact; -} VkPhysicalDeviceDepthBiasControlFeaturesEXT32; + VkBool32 descriptorBuffer; + VkBool32 descriptorBufferCaptureReplay; + VkBool32 descriptorBufferImageLayoutIgnored; + VkBool32 descriptorBufferPushDescriptors; +} VkPhysicalDeviceDescriptorBufferFeaturesEXT32;

-typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 +typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 rayTracingInvocationReorder; -} VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32; + VkBool32 combinedImageSamplerDescriptorSingleArray; + VkBool32 bufferlessPushDescriptors; + VkBool32 allowSamplerImageViewPostSubmitCreation; + VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferOffsetAlignment; + uint32_t maxDescriptorBufferBindings; + uint32_t maxResourceDescriptorBufferBindings; + uint32_t maxSamplerDescriptorBufferBindings; + uint32_t maxEmbeddedImmutableSamplerBindings; + uint32_t maxEmbeddedImmutableSamplers; + PTR32 bufferCaptureReplayDescriptorDataSize; + PTR32 imageCaptureReplayDescriptorDataSize; + PTR32 imageViewCaptureReplayDescriptorDataSize; + PTR32 samplerCaptureReplayDescriptorDataSize; + PTR32 accelerationStructureCaptureReplayDescriptorDataSize; + PTR32 samplerDescriptorSize; + PTR32 combinedImageSamplerDescriptorSize; + PTR32 sampledImageDescriptorSize; + PTR32 storageImageDescriptorSize; + PTR32 uniformTexelBufferDescriptorSize; + PTR32 robustUniformTexelBufferDescriptorSize; + PTR32 storageTexelBufferDescriptorSize; + PTR32 robustStorageTexelBufferDescriptorSize; + PTR32 uniformBufferDescriptorSize; + PTR32 robustUniformBufferDescriptorSize; + PTR32 storageBufferDescriptorSize; + PTR32 robustStorageBufferDescriptorSize; + PTR32 inputAttachmentDescriptorSize; + PTR32 accelerationStructureDescriptorSize; + VkDeviceSize DECLSPEC_ALIGN(8) maxSamplerDescriptorBufferRange; + VkDeviceSize DECLSPEC_ALIGN(8) maxResourceDescriptorBufferRange; + VkDeviceSize DECLSPEC_ALIGN(8) samplerDescriptorBufferAddressSpaceSize; + VkDeviceSize DECLSPEC_ALIGN(8) resourceDescriptorBufferAddressSpaceSize; + VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferAddressSpaceSize; +} VkPhysicalDeviceDescriptorBufferPropertiesEXT32;

-typedef struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 +typedef struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 extendedSparseAddressSpace; -} VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32; + VkBool32 descriptorBufferTensorDescriptors; +} VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32;

-typedef struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 +typedef struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 multiviewPerViewViewports; -} VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32; + PTR32 tensorCaptureReplayDescriptorDataSize; + PTR32 tensorViewCaptureReplayDescriptorDataSize; + PTR32 tensorDescriptorSize; +} VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32;

-typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 +typedef struct VkPhysicalDeviceDescriptorIndexingFeatures32 { VkStructureType sType; PTR32 pNext; - VkBool32 rayTracingPositionFetch; -} VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; +} VkPhysicalDeviceDescriptorIndexingFeatures32; +typedef VkPhysicalDeviceDescriptorIndexingFeatures32 VkPhysicalDeviceDescriptorIndexingFeaturesEXT32;

-typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 +typedef struct VkPhysicalDeviceDescriptorIndexingProperties32 { VkStructureType sType; PTR32 pNext; - VkBool32 multiviewPerViewRenderAreas; -} VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; +} VkPhysicalDeviceDescriptorIndexingProperties32; +typedef VkPhysicalDeviceDescriptorIndexingProperties32 VkPhysicalDeviceDescriptorIndexingPropertiesEXT32;

-typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT32 +typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderObject; -} VkPhysicalDeviceShaderObjectFeaturesEXT32; + VkBool32 descriptorPoolOverallocation; +} VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32;

-typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT32 +typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderTileImageColorReadAccess; - VkBool32 shaderTileImageDepthReadAccess; - VkBool32 shaderTileImageStencilReadAccess; -} VkPhysicalDeviceShaderTileImageFeaturesEXT32; + VkBool32 descriptorSetHostMapping; +} VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32;

-typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 cooperativeMatrix; - VkBool32 cooperativeMatrixRobustBufferAccess; -} VkPhysicalDeviceCooperativeMatrixFeaturesKHR32; + VkBool32 deviceGeneratedCompute; + VkBool32 deviceGeneratedComputePipelines; + VkBool32 deviceGeneratedComputeCaptureReplay; +} VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32;

-typedef struct VkPhysicalDeviceAntiLagFeaturesAMD32 +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 antiLag; -} VkPhysicalDeviceAntiLagFeaturesAMD32; + VkBool32 deviceGeneratedCommands; + VkBool32 dynamicGeneratedPipelineLayout; +} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32;

-typedef struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 tileMemoryHeap; -} VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32; + VkBool32 deviceGeneratedCommands; +} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32;

-typedef struct VkPhysicalDeviceCubicClampFeaturesQCOM32 +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 cubicRangeClamp; -} VkPhysicalDeviceCubicClampFeaturesQCOM32; + uint32_t maxIndirectPipelineCount; + uint32_t maxIndirectShaderObjectCount; + uint32_t maxIndirectSequenceCount; + uint32_t maxIndirectCommandsTokenCount; + uint32_t maxIndirectCommandsTokenOffset; + uint32_t maxIndirectCommandsIndirectStride; + VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes; + VkShaderStageFlags supportedIndirectCommandsShaderStages; + VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding; + VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding; + VkBool32 deviceGeneratedCommandsTransformFeedback; + VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount; +} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32;

-typedef struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 ycbcrDegamma; -} VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32; + uint32_t maxGraphicsShaderGroupCount; + uint32_t maxIndirectSequenceCount; + uint32_t maxIndirectCommandsTokenCount; + uint32_t maxIndirectCommandsStreamCount; + uint32_t maxIndirectCommandsTokenOffset; + uint32_t maxIndirectCommandsStreamStride; + uint32_t minSequencesCountBufferOffsetAlignment; + uint32_t minSequencesIndexBufferOffsetAlignment; + uint32_t minIndirectCommandsBufferOffsetAlignment; +} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32;

-typedef struct VkPhysicalDeviceCubicWeightsFeaturesQCOM32 +typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 selectableCubicWeights; -} VkPhysicalDeviceCubicWeightsFeaturesQCOM32; + VkBool32 diagnosticsConfig; +} VkPhysicalDeviceDiagnosticsConfigFeaturesNV32;

-typedef struct VkPhysicalDeviceImageProcessing2FeaturesQCOM32 +typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 textureBlockMatch2; -} VkPhysicalDeviceImageProcessing2FeaturesQCOM32; + uint32_t maxDiscardRectangles; +} VkPhysicalDeviceDiscardRectanglePropertiesEXT32;

-typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 +typedef struct VkPhysicalDeviceDriverProperties32 { VkStructureType sType; PTR32 pNext; - VkBool32 descriptorPoolOverallocation; -} VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32; + VkDriverId driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; + VkConformanceVersion conformanceVersion; +} VkPhysicalDeviceDriverProperties32; +typedef VkPhysicalDeviceDriverProperties32 VkPhysicalDeviceDriverPropertiesKHR32;

-typedef struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 +typedef struct VkPhysicalDeviceDynamicRenderingFeatures32 { VkStructureType sType; PTR32 pNext; - VkBool32 perStageDescriptorSet; - VkBool32 dynamicPipelineLayout; -} VkPhysicalDevicePerStageDescriptorSetFeaturesNV32; + VkBool32 dynamicRendering; +} VkPhysicalDeviceDynamicRenderingFeatures32; +typedef VkPhysicalDeviceDynamicRenderingFeatures32 VkPhysicalDeviceDynamicRenderingFeaturesKHR32;

-typedef struct VkPhysicalDeviceSchedulingControlsFeaturesARM32 +typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 { VkStructureType sType; PTR32 pNext; - VkBool32 schedulingControls; -} VkPhysicalDeviceSchedulingControlsFeaturesARM32; + VkBool32 dynamicRenderingLocalRead; +} VkPhysicalDeviceDynamicRenderingLocalReadFeatures32; +typedef VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR32;

-typedef struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 +typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 relaxedLineRasterization; -} VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32; + VkBool32 dynamicRenderingUnusedAttachments; +} VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32;

-typedef struct VkPhysicalDeviceRenderPassStripedFeaturesARM32 +typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 renderPassStriped; -} VkPhysicalDeviceRenderPassStripedFeaturesARM32; + VkBool32 exclusiveScissor; +} VkPhysicalDeviceExclusiveScissorFeaturesNV32;

-typedef struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 +typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 pipelineOpacityMicromap; -} VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32; + VkBool32 extendedDynamicState2; + VkBool32 extendedDynamicState2LogicOp; + VkBool32 extendedDynamicState2PatchControlPoints; +} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32;

-typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 +typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderMaximalReconvergence; -} VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32; + VkBool32 extendedDynamicState3TessellationDomainOrigin; + VkBool32 extendedDynamicState3DepthClampEnable; + VkBool32 extendedDynamicState3PolygonMode; + VkBool32 extendedDynamicState3RasterizationSamples; + VkBool32 extendedDynamicState3SampleMask; + VkBool32 extendedDynamicState3AlphaToCoverageEnable; + VkBool32 extendedDynamicState3AlphaToOneEnable; + VkBool32 extendedDynamicState3LogicOpEnable; + VkBool32 extendedDynamicState3ColorBlendEnable; + VkBool32 extendedDynamicState3ColorBlendEquation; + VkBool32 extendedDynamicState3ColorWriteMask; + VkBool32 extendedDynamicState3RasterizationStream; + VkBool32 extendedDynamicState3ConservativeRasterizationMode; + VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize; + VkBool32 extendedDynamicState3DepthClipEnable; + VkBool32 extendedDynamicState3SampleLocationsEnable; + VkBool32 extendedDynamicState3ColorBlendAdvanced; + VkBool32 extendedDynamicState3ProvokingVertexMode; + VkBool32 extendedDynamicState3LineRasterizationMode; + VkBool32 extendedDynamicState3LineStippleEnable; + VkBool32 extendedDynamicState3DepthClipNegativeOneToOne; + VkBool32 extendedDynamicState3ViewportWScalingEnable; + VkBool32 extendedDynamicState3ViewportSwizzle; + VkBool32 extendedDynamicState3CoverageToColorEnable; + VkBool32 extendedDynamicState3CoverageToColorLocation; + VkBool32 extendedDynamicState3CoverageModulationMode; + VkBool32 extendedDynamicState3CoverageModulationTableEnable; + VkBool32 extendedDynamicState3CoverageModulationTable; + VkBool32 extendedDynamicState3CoverageReductionMode; + VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable; + VkBool32 extendedDynamicState3ShadingRateImageEnable; +} VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32;

-typedef struct VkPhysicalDeviceShaderSubgroupRotateFeatures32 +typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderSubgroupRotate; - VkBool32 shaderSubgroupRotateClustered; -} VkPhysicalDeviceShaderSubgroupRotateFeatures32; -typedef VkPhysicalDeviceShaderSubgroupRotateFeatures32 VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR32; + VkBool32 dynamicPrimitiveTopologyUnrestricted; +} VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32;

-typedef struct VkPhysicalDeviceShaderExpectAssumeFeatures32 +typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderExpectAssume; -} VkPhysicalDeviceShaderExpectAssumeFeatures32; -typedef VkPhysicalDeviceShaderExpectAssumeFeatures32 VkPhysicalDeviceShaderExpectAssumeFeaturesKHR32; + VkBool32 extendedDynamicState; +} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32;

-typedef struct VkPhysicalDeviceShaderFloatControls2Features32 +typedef struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderFloatControls2; -} VkPhysicalDeviceShaderFloatControls2Features32; -typedef VkPhysicalDeviceShaderFloatControls2Features32 VkPhysicalDeviceShaderFloatControls2FeaturesKHR32; + VkBool32 extendedSparseAddressSpace; +} VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32;

-typedef struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 +typedef struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 dynamicRenderingLocalRead; -} VkPhysicalDeviceDynamicRenderingLocalReadFeatures32; -typedef VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR32; + VkDeviceSize DECLSPEC_ALIGN(8) extendedSparseAddressSpaceSize; + VkImageUsageFlags extendedSparseImageUsageFlags; + VkBufferUsageFlags extendedSparseBufferUsageFlags; +} VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV32;

-typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR32 +typedef struct VkPhysicalDeviceExternalBufferInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderQuadControl; -} VkPhysicalDeviceShaderQuadControlFeaturesKHR32; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalBufferInfo32; +typedef VkPhysicalDeviceExternalBufferInfo32 VkPhysicalDeviceExternalBufferInfoKHR32;

-typedef struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 +typedef struct VkPhysicalDeviceExternalFenceInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderFloat16VectorAtomics; -} VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32; + VkExternalFenceHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalFenceInfo32; +typedef VkPhysicalDeviceExternalFenceInfo32 VkPhysicalDeviceExternalFenceInfoKHR32;

-typedef struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 +typedef struct VkPhysicalDeviceExternalImageFormatInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 memoryMapPlaced; - VkBool32 memoryMapRangePlaced; - VkBool32 memoryUnmapReserve; -} VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalImageFormatInfo32; +typedef VkPhysicalDeviceExternalImageFormatInfo32 VkPhysicalDeviceExternalImageFormatInfoKHR32;

-typedef struct VkPhysicalDeviceShaderBfloat16FeaturesKHR32 +typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderBFloat16Type; - VkBool32 shaderBFloat16DotProduct; - VkBool32 shaderBFloat16CooperativeMatrix; -} VkPhysicalDeviceShaderBfloat16FeaturesKHR32; + VkDeviceSize DECLSPEC_ALIGN(8) minImportedHostPointerAlignment; +} VkPhysicalDeviceExternalMemoryHostPropertiesEXT32;

-typedef struct VkPhysicalDeviceRawAccessChainsFeaturesNV32 +typedef struct VkPhysicalDeviceExternalSemaphoreInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderRawAccessChains; -} VkPhysicalDeviceRawAccessChainsFeaturesNV32; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalSemaphoreInfo32; +typedef VkPhysicalDeviceExternalSemaphoreInfo32 VkPhysicalDeviceExternalSemaphoreInfoKHR32;

-typedef struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 +typedef struct VkPhysicalDeviceExternalTensorInfoARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 commandBufferInheritance; -} VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32; + VkTensorCreateFlagsARM DECLSPEC_ALIGN(8) flags; + PTR32 pDescription; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalTensorInfoARM32;

-typedef struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 +typedef struct VkPhysicalDeviceFaultFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 imageAlignmentControl; -} VkPhysicalDeviceImageAlignmentControlFeaturesMESA32; + VkBool32 deviceFault; + VkBool32 deviceFaultVendorBinary; +} VkPhysicalDeviceFaultFeaturesEXT32;

-typedef struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 +typedef struct VkPhysicalDeviceFeatures232 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderReplicatedComposites; -} VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32; + VkPhysicalDeviceFeatures features; +} VkPhysicalDeviceFeatures232; +typedef VkPhysicalDeviceFeatures232 VkPhysicalDeviceFeatures2KHR32;

-typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 +typedef struct VkPhysicalDeviceFloatControlsProperties32 { VkStructureType sType; PTR32 pNext; - VkBool32 presentModeFifoLatestReady; -} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32; -typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; +} VkPhysicalDeviceFloatControlsProperties32; +typedef VkPhysicalDeviceFloatControlsProperties32 VkPhysicalDeviceFloatControlsPropertiesKHR32;

-typedef struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 +typedef struct VkPhysicalDeviceFormatPackFeaturesARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 cooperativeMatrixWorkgroupScope; - VkBool32 cooperativeMatrixFlexibleDimensions; - VkBool32 cooperativeMatrixReductions; - VkBool32 cooperativeMatrixConversions; - VkBool32 cooperativeMatrixPerElementOperations; - VkBool32 cooperativeMatrixTensorAddressing; - VkBool32 cooperativeMatrixBlockLoads; -} VkPhysicalDeviceCooperativeMatrix2FeaturesNV32; + VkBool32 formatPack; +} VkPhysicalDeviceFormatPackFeaturesARM32;

-typedef struct VkPhysicalDeviceHdrVividFeaturesHUAWEI32 +typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 hdrVivid; -} VkPhysicalDeviceHdrVividFeaturesHUAWEI32; + VkBool32 fragmentDensityMapDeferred; +} VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32;

-typedef struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 +typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 vertexAttributeRobustness; -} VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32; + VkBool32 subsampledLoads; + VkBool32 subsampledCoarseReconstructionEarlyAccess; + uint32_t maxSubsampledArrayLayers; + uint32_t maxDescriptorSetSubsampledSamplers; +} VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32;

-typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 +typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 depthClampZeroOne; -} VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32; -typedef VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 VkPhysicalDeviceDepthClampZeroOneFeaturesEXT32; + VkBool32 fragmentDensityMap; + VkBool32 fragmentDensityMapDynamic; + VkBool32 fragmentDensityMapNonSubsampledImages; +} VkPhysicalDeviceFragmentDensityMapFeaturesEXT32;

-typedef struct VkPhysicalDeviceCooperativeVectorFeaturesNV32 +typedef struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32 { VkStructureType sType; PTR32 pNext; - VkBool32 cooperativeVector; - VkBool32 cooperativeVectorTraining; -} VkPhysicalDeviceCooperativeVectorFeaturesNV32; + VkBool32 fragmentDensityMapLayered; +} VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32;

-typedef struct VkPhysicalDeviceTileShadingFeaturesQCOM32 +typedef struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32 { VkStructureType sType; PTR32 pNext; - VkBool32 tileShading; - VkBool32 tileShadingFragmentStage; - VkBool32 tileShadingColorAttachments; - VkBool32 tileShadingDepthAttachments; - VkBool32 tileShadingStencilAttachments; - VkBool32 tileShadingInputAttachments; - VkBool32 tileShadingSampledAttachments; - VkBool32 tileShadingPerTileDraw; - VkBool32 tileShadingPerTileDispatch; - VkBool32 tileShadingDispatchTile; - VkBool32 tileShadingApron; - VkBool32 tileShadingAnisotropicApron; - VkBool32 tileShadingAtomicOps; - VkBool32 tileShadingImageProcessing; -} VkPhysicalDeviceTileShadingFeaturesQCOM32; + uint32_t maxFragmentDensityMapLayers; +} VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32;

-typedef struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32 +typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 fragmentDensityMapLayered; -} VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32; + VkBool32 fragmentDensityMapOffset; +} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32; +typedef VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM32;

-typedef struct VkPhysicalDeviceFormatPackFeaturesARM32 +typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 formatPack; -} VkPhysicalDeviceFormatPackFeaturesARM32; + VkExtent2D fragmentDensityOffsetGranularity; +} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32; +typedef VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32 VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32;

-typedef struct VkPhysicalDeviceTensorFeaturesARM32 +typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 tensorNonPacked; - VkBool32 shaderTensorAccess; - VkBool32 shaderStorageTensorArrayDynamicIndexing; - VkBool32 shaderStorageTensorArrayNonUniformIndexing; - VkBool32 descriptorBindingStorageTensorUpdateAfterBind; - VkBool32 tensors; -} VkPhysicalDeviceTensorFeaturesARM32; + VkExtent2D minFragmentDensityTexelSize; + VkExtent2D maxFragmentDensityTexelSize; + VkBool32 fragmentDensityInvocations; +} VkPhysicalDeviceFragmentDensityMapPropertiesEXT32;

-typedef struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 +typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 descriptorBufferTensorDescriptors; -} VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32; + VkBool32 fragmentShaderBarycentric; +} VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32; +typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV32;

-typedef struct VkPhysicalDeviceShaderFloat8FeaturesEXT32 +typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderFloat8; - VkBool32 shaderFloat8CooperativeMatrix; -} VkPhysicalDeviceShaderFloat8FeaturesEXT32; + VkBool32 triStripVertexOrderIndependentOfProvokingVertex; +} VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32;

-typedef struct VkPhysicalDeviceDataGraphFeaturesARM32 +typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 dataGraph; - VkBool32 dataGraphUpdateAfterBind; - VkBool32 dataGraphSpecializationConstants; - VkBool32 dataGraphDescriptorBuffer; - VkBool32 dataGraphShaderModule; -} VkPhysicalDeviceDataGraphFeaturesARM32; + VkBool32 fragmentShaderSampleInterlock; + VkBool32 fragmentShaderPixelInterlock; + VkBool32 fragmentShaderShadingRateInterlock; +} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32;

-typedef struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 +typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 pipelineCacheIncrementalMode; -} VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32; + VkBool32 fragmentShadingRateEnums; + VkBool32 supersampleFragmentShadingRates; + VkBool32 noInvocationFragmentShadingRates; +} VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32;

-typedef struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 +typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderUntypedPointers; -} VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32; + VkSampleCountFlagBits maxFragmentShadingRateInvocationCount; +} VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32;

-typedef struct VkDeviceCreateInfo32 +typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkDeviceCreateFlags flags; - uint32_t queueCreateInfoCount; - PTR32 pQueueCreateInfos; - uint32_t enabledLayerCount; - PTR32 ppEnabledLayerNames; - uint32_t enabledExtensionCount; - PTR32 ppEnabledExtensionNames; - PTR32 pEnabledFeatures; -} VkDeviceCreateInfo32; + VkBool32 pipelineFragmentShadingRate; + VkBool32 primitiveFragmentShadingRate; + VkBool32 attachmentFragmentShadingRate; +} VkPhysicalDeviceFragmentShadingRateFeaturesKHR32;

-typedef struct VkEventCreateInfo32 +typedef struct VkPhysicalDeviceFragmentShadingRateKHR32 { VkStructureType sType; PTR32 pNext; - VkEventCreateFlags flags; -} VkEventCreateInfo32; + VkSampleCountFlags sampleCounts; + VkExtent2D fragmentSize; +} VkPhysicalDeviceFragmentShadingRateKHR32;

-typedef struct VkExportFenceCreateInfo32 +typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR32 { VkStructureType sType; PTR32 pNext; - VkExternalFenceHandleTypeFlags handleTypes; -} VkExportFenceCreateInfo32; -typedef VkExportFenceCreateInfo32 VkExportFenceCreateInfoKHR32; + VkExtent2D minFragmentShadingRateAttachmentTexelSize; + VkExtent2D maxFragmentShadingRateAttachmentTexelSize; + uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; + VkBool32 primitiveFragmentShadingRateWithMultipleViewports; + VkBool32 layeredShadingRateAttachments; + VkBool32 fragmentShadingRateNonTrivialCombinerOps; + VkExtent2D maxFragmentSize; + uint32_t maxFragmentSizeAspectRatio; + uint32_t maxFragmentShadingRateCoverageSamples; + VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; + VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; + VkBool32 fragmentShadingRateWithSampleMask; + VkBool32 fragmentShadingRateWithShaderSampleMask; + VkBool32 fragmentShadingRateWithConservativeRasterization; + VkBool32 fragmentShadingRateWithFragmentShaderInterlock; + VkBool32 fragmentShadingRateWithCustomSampleLocations; + VkBool32 fragmentShadingRateStrictMultiplyCombiner; +} VkPhysicalDeviceFragmentShadingRatePropertiesKHR32;

-typedef struct VkFenceCreateInfo32 +typedef struct VkPhysicalDeviceFrameBoundaryFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkFenceCreateFlags flags; -} VkFenceCreateInfo32; + VkBool32 frameBoundary; +} VkPhysicalDeviceFrameBoundaryFeaturesEXT32;

-typedef struct VkFramebufferAttachmentImageInfo32 +typedef struct VkPhysicalDeviceGlobalPriorityQueryFeatures32 { VkStructureType sType; PTR32 pNext; - VkImageCreateFlags flags; - VkImageUsageFlags usage; - uint32_t width; - uint32_t height; - uint32_t layerCount; - uint32_t viewFormatCount; - PTR32 pViewFormats; -} VkFramebufferAttachmentImageInfo32; -typedef VkFramebufferAttachmentImageInfo32 VkFramebufferAttachmentImageInfoKHR32; + VkBool32 globalPriorityQuery; +} VkPhysicalDeviceGlobalPriorityQueryFeatures32; +typedef VkPhysicalDeviceGlobalPriorityQueryFeatures32 VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR32; +typedef VkPhysicalDeviceGlobalPriorityQueryFeatures32 VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT32;

-typedef struct VkFramebufferAttachmentsCreateInfo32 +typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t attachmentImageInfoCount; - PTR32 pAttachmentImageInfos; -} VkFramebufferAttachmentsCreateInfo32; -typedef VkFramebufferAttachmentsCreateInfo32 VkFramebufferAttachmentsCreateInfoKHR32; + VkBool32 graphicsPipelineLibrary; +} VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32;

-typedef struct VkFramebufferCreateInfo32 +typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkFramebufferCreateFlags flags; - VkRenderPass DECLSPEC_ALIGN(8) renderPass; - uint32_t attachmentCount; - PTR32 pAttachments; - uint32_t width; - uint32_t height; - uint32_t layers; -} VkFramebufferCreateInfo32; + VkBool32 graphicsPipelineLibraryFastLinking; + VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration; +} VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32;

-typedef struct VkPipelineVertexInputDivisorStateCreateInfo32 +typedef struct VkPhysicalDeviceGroupProperties32 { VkStructureType sType; PTR32 pNext; - uint32_t vertexBindingDivisorCount; - PTR32 pVertexBindingDivisors; -} VkPipelineVertexInputDivisorStateCreateInfo32; -typedef VkPipelineVertexInputDivisorStateCreateInfo32 VkPipelineVertexInputDivisorStateCreateInfoKHR32; -typedef VkPipelineVertexInputDivisorStateCreateInfo32 VkPipelineVertexInputDivisorStateCreateInfoEXT32; + uint32_t physicalDeviceCount; + PTR32 physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; + VkBool32 subsetAllocation; +} VkPhysicalDeviceGroupProperties32; +typedef VkPhysicalDeviceGroupProperties32 VkPhysicalDeviceGroupPropertiesKHR32;

-typedef struct VkPipelineVertexInputStateCreateInfo32 +typedef struct VkPhysicalDeviceHdrVividFeaturesHUAWEI32 { VkStructureType sType; PTR32 pNext; - VkPipelineVertexInputStateCreateFlags flags; - uint32_t vertexBindingDescriptionCount; - PTR32 pVertexBindingDescriptions; - uint32_t vertexAttributeDescriptionCount; - PTR32 pVertexAttributeDescriptions; -} VkPipelineVertexInputStateCreateInfo32; + VkBool32 hdrVivid; +} VkPhysicalDeviceHdrVividFeaturesHUAWEI32;

-typedef struct VkPipelineTessellationDomainOriginStateCreateInfo32 +typedef struct VkPhysicalDeviceHostImageCopyFeatures32 { VkStructureType sType; PTR32 pNext; - VkTessellationDomainOrigin domainOrigin; -} VkPipelineTessellationDomainOriginStateCreateInfo32; -typedef VkPipelineTessellationDomainOriginStateCreateInfo32 VkPipelineTessellationDomainOriginStateCreateInfoKHR32; + VkBool32 hostImageCopy; +} VkPhysicalDeviceHostImageCopyFeatures32; +typedef VkPhysicalDeviceHostImageCopyFeatures32 VkPhysicalDeviceHostImageCopyFeaturesEXT32;

-typedef struct VkPipelineTessellationStateCreateInfo32 +typedef struct VkPhysicalDeviceHostImageCopyProperties32 { VkStructureType sType; PTR32 pNext; - VkPipelineTessellationStateCreateFlags flags; - uint32_t patchControlPoints; -} VkPipelineTessellationStateCreateInfo32; + uint32_t copySrcLayoutCount; + PTR32 pCopySrcLayouts; + uint32_t copyDstLayoutCount; + PTR32 pCopyDstLayouts; + uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; + VkBool32 identicalMemoryTypeRequirements; +} VkPhysicalDeviceHostImageCopyProperties32; +typedef VkPhysicalDeviceHostImageCopyProperties32 VkPhysicalDeviceHostImageCopyPropertiesEXT32;

-typedef struct VkGraphicsShaderGroupCreateInfoNV32 +typedef struct VkPhysicalDeviceHostQueryResetFeatures32 { VkStructureType sType; PTR32 pNext; - uint32_t stageCount; - PTR32 pStages; - PTR32 pVertexInputState; - PTR32 pTessellationState; -} VkGraphicsShaderGroupCreateInfoNV32; + VkBool32 hostQueryReset; +} VkPhysicalDeviceHostQueryResetFeatures32; +typedef VkPhysicalDeviceHostQueryResetFeatures32 VkPhysicalDeviceHostQueryResetFeaturesEXT32;

-typedef struct VkPipelineInputAssemblyStateCreateInfo32 +typedef struct VkPhysicalDeviceIDProperties32 { VkStructureType sType; PTR32 pNext; - VkPipelineInputAssemblyStateCreateFlags flags; - VkPrimitiveTopology topology; - VkBool32 primitiveRestartEnable; -} VkPipelineInputAssemblyStateCreateInfo32; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDProperties32; +typedef VkPhysicalDeviceIDProperties32 VkPhysicalDeviceIDPropertiesKHR32;

-typedef struct VkPipelineViewportWScalingStateCreateInfoNV32 +typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 viewportWScalingEnable; - uint32_t viewportCount; - PTR32 pViewportWScalings; -} VkPipelineViewportWScalingStateCreateInfoNV32; + VkBool32 image2DViewOf3D; + VkBool32 sampler2DViewOf3D; +} VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32;

-typedef struct VkPipelineViewportSwizzleStateCreateInfoNV32 +typedef struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 { VkStructureType sType; PTR32 pNext; - VkPipelineViewportSwizzleStateCreateFlagsNV flags; - uint32_t viewportCount; - PTR32 pViewportSwizzles; -} VkPipelineViewportSwizzleStateCreateInfoNV32; + VkBool32 imageAlignmentControl; +} VkPhysicalDeviceImageAlignmentControlFeaturesMESA32;

-typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV32 +typedef struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA32 { VkStructureType sType; PTR32 pNext; - uint32_t exclusiveScissorCount; - PTR32 pExclusiveScissors; -} VkPipelineViewportExclusiveScissorStateCreateInfoNV32; + uint32_t supportedImageAlignmentMask; +} VkPhysicalDeviceImageAlignmentControlPropertiesMESA32;

-typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV32 +typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 shadingRateImageEnable; - uint32_t viewportCount; - PTR32 pShadingRatePalettes; -} VkPipelineViewportShadingRateImageStateCreateInfoNV32; + VkBool32 imageCompressionControl; +} VkPhysicalDeviceImageCompressionControlFeaturesEXT32;

-typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 +typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkCoarseSampleOrderTypeNV sampleOrderType; - uint32_t customSampleOrderCount; - PTR32 pCustomSampleOrders; -} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32; + VkBool32 imageCompressionControlSwapchain; +} VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32;

-typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT32 +typedef struct VkPhysicalDeviceImageFormatInfo232 { VkStructureType sType; PTR32 pNext; - VkBool32 negativeOneToOne; -} VkPipelineViewportDepthClipControlCreateInfoEXT32; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} VkPhysicalDeviceImageFormatInfo232; +typedef VkPhysicalDeviceImageFormatInfo232 VkPhysicalDeviceImageFormatInfo2KHR32;

-typedef struct VkPipelineViewportDepthClampControlCreateInfoEXT32 +typedef struct VkPhysicalDeviceImageProcessing2FeaturesQCOM32 { VkStructureType sType; PTR32 pNext; - VkDepthClampModeEXT depthClampMode; - PTR32 pDepthClampRange; -} VkPipelineViewportDepthClampControlCreateInfoEXT32; + VkBool32 textureBlockMatch2; +} VkPhysicalDeviceImageProcessing2FeaturesQCOM32;

-typedef struct VkPipelineViewportStateCreateInfo32 +typedef struct VkPhysicalDeviceImageProcessing2PropertiesQCOM32 { VkStructureType sType; PTR32 pNext; - VkPipelineViewportStateCreateFlags flags; - uint32_t viewportCount; - PTR32 pViewports; - uint32_t scissorCount; - PTR32 pScissors; -} VkPipelineViewportStateCreateInfo32; + VkExtent2D maxBlockMatchWindow; +} VkPhysicalDeviceImageProcessing2PropertiesQCOM32;

-typedef struct VkPipelineRasterizationStateRasterizationOrderAMD32 +typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM32 { VkStructureType sType; PTR32 pNext; - VkRasterizationOrderAMD rasterizationOrder; -} VkPipelineRasterizationStateRasterizationOrderAMD32; + VkBool32 textureSampleWeighted; + VkBool32 textureBoxFilter; + VkBool32 textureBlockMatch; +} VkPhysicalDeviceImageProcessingFeaturesQCOM32;

-typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT32 +typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM32 { VkStructureType sType; PTR32 pNext; - VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; - VkConservativeRasterizationModeEXT conservativeRasterizationMode; - float extraPrimitiveOverestimationSize; -} VkPipelineRasterizationConservativeStateCreateInfoEXT32; + uint32_t maxWeightFilterPhases; + VkExtent2D maxWeightFilterDimension; + VkExtent2D maxBlockMatchRegion; + VkExtent2D maxBoxFilterBlockSize; +} VkPhysicalDeviceImageProcessingPropertiesQCOM32;

-typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT32 +typedef struct VkPhysicalDeviceImageRobustnessFeatures32 { VkStructureType sType; PTR32 pNext; - VkPipelineRasterizationStateStreamCreateFlagsEXT flags; - uint32_t rasterizationStream; -} VkPipelineRasterizationStateStreamCreateInfoEXT32; + VkBool32 robustImageAccess; +} VkPhysicalDeviceImageRobustnessFeatures32; +typedef VkPhysicalDeviceImageRobustnessFeatures32 VkPhysicalDeviceImageRobustnessFeaturesEXT32;

-typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT32 +typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; - VkBool32 depthClipEnable; -} VkPipelineRasterizationDepthClipStateCreateInfoEXT32; + VkBool32 imageSlicedViewOf3D; +} VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32;

-typedef struct VkPipelineRasterizationLineStateCreateInfo32 +typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkLineRasterizationMode lineRasterizationMode; - VkBool32 stippledLineEnable; - uint32_t lineStippleFactor; - uint16_t lineStipplePattern; -} VkPipelineRasterizationLineStateCreateInfo32; -typedef VkPipelineRasterizationLineStateCreateInfo32 VkPipelineRasterizationLineStateCreateInfoKHR32; -typedef VkPipelineRasterizationLineStateCreateInfo32 VkPipelineRasterizationLineStateCreateInfoEXT32; + VkImageViewType imageViewType; +} VkPhysicalDeviceImageViewImageFormatInfoEXT32;

-typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 +typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkProvokingVertexModeEXT provokingVertexMode; -} VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32; + VkBool32 minLod; +} VkPhysicalDeviceImageViewMinLodFeaturesEXT32;

-typedef struct VkPipelineRasterizationStateCreateInfo32 +typedef struct VkPhysicalDeviceImagelessFramebufferFeatures32 { VkStructureType sType; PTR32 pNext; - VkPipelineRasterizationStateCreateFlags flags; - VkBool32 depthClampEnable; - VkBool32 rasterizerDiscardEnable; - VkPolygonMode polygonMode; - VkCullModeFlags cullMode; - VkFrontFace frontFace; - VkBool32 depthBiasEnable; - float depthBiasConstantFactor; - float depthBiasClamp; - float depthBiasSlopeFactor; - float lineWidth; -} VkPipelineRasterizationStateCreateInfo32; + VkBool32 imagelessFramebuffer; +} VkPhysicalDeviceImagelessFramebufferFeatures32; +typedef VkPhysicalDeviceImagelessFramebufferFeatures32 VkPhysicalDeviceImagelessFramebufferFeaturesKHR32;

-typedef struct VkPipelineCoverageToColorStateCreateInfoNV32 +typedef struct VkPhysicalDeviceIndexTypeUint8Features32 { VkStructureType sType; PTR32 pNext; - VkPipelineCoverageToColorStateCreateFlagsNV flags; - VkBool32 coverageToColorEnable; - uint32_t coverageToColorLocation; -} VkPipelineCoverageToColorStateCreateInfoNV32; + VkBool32 indexTypeUint8; +} VkPhysicalDeviceIndexTypeUint8Features32; +typedef VkPhysicalDeviceIndexTypeUint8Features32 VkPhysicalDeviceIndexTypeUint8FeaturesKHR32; +typedef VkPhysicalDeviceIndexTypeUint8Features32 VkPhysicalDeviceIndexTypeUint8FeaturesEXT32;

-typedef struct VkPipelineSampleLocationsStateCreateInfoEXT32 +typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 sampleLocationsEnable; - VkSampleLocationsInfoEXT32 sampleLocationsInfo; -} VkPipelineSampleLocationsStateCreateInfoEXT32; + VkBool32 inheritedViewportScissor2D; +} VkPhysicalDeviceInheritedViewportScissorFeaturesNV32;

-typedef struct VkPipelineCoverageModulationStateCreateInfoNV32 +typedef struct VkPhysicalDeviceInlineUniformBlockFeatures32 { VkStructureType sType; PTR32 pNext; - VkPipelineCoverageModulationStateCreateFlagsNV flags; - VkCoverageModulationModeNV coverageModulationMode; - VkBool32 coverageModulationTableEnable; - uint32_t coverageModulationTableCount; - PTR32 pCoverageModulationTable; -} VkPipelineCoverageModulationStateCreateInfoNV32; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; +} VkPhysicalDeviceInlineUniformBlockFeatures32; +typedef VkPhysicalDeviceInlineUniformBlockFeatures32 VkPhysicalDeviceInlineUniformBlockFeaturesEXT32;

-typedef struct VkPipelineCoverageReductionStateCreateInfoNV32 +typedef struct VkPhysicalDeviceInlineUniformBlockProperties32 { VkStructureType sType; PTR32 pNext; - VkPipelineCoverageReductionStateCreateFlagsNV flags; - VkCoverageReductionModeNV coverageReductionMode; -} VkPipelineCoverageReductionStateCreateInfoNV32; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; +} VkPhysicalDeviceInlineUniformBlockProperties32; +typedef VkPhysicalDeviceInlineUniformBlockProperties32 VkPhysicalDeviceInlineUniformBlockPropertiesEXT32;

-typedef struct VkPipelineMultisampleStateCreateInfo32 +typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 { VkStructureType sType; PTR32 pNext; - VkPipelineMultisampleStateCreateFlags flags; - VkSampleCountFlagBits rasterizationSamples; - VkBool32 sampleShadingEnable; - float minSampleShading; - PTR32 pSampleMask; - VkBool32 alphaToCoverageEnable; - VkBool32 alphaToOneEnable; -} VkPipelineMultisampleStateCreateInfo32; + VkBool32 invocationMask; +} VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32;

-typedef struct VkPipelineDepthStencilStateCreateInfo32 +typedef struct VkPhysicalDeviceLayeredDriverPropertiesMSFT32 { VkStructureType sType; PTR32 pNext; - VkPipelineDepthStencilStateCreateFlags flags; - VkBool32 depthTestEnable; - VkBool32 depthWriteEnable; - VkCompareOp depthCompareOp; - VkBool32 depthBoundsTestEnable; - VkBool32 stencilTestEnable; - VkStencilOpState front; - VkStencilOpState back; - float minDepthBounds; - float maxDepthBounds; -} VkPipelineDepthStencilStateCreateInfo32; + VkLayeredDriverUnderlyingApiMSFT underlyingAPI; +} VkPhysicalDeviceLayeredDriverPropertiesMSFT32;

-typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT32 +typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 srcPremultiplied; - VkBool32 dstPremultiplied; - VkBlendOverlapEXT blendOverlap; -} VkPipelineColorBlendAdvancedStateCreateInfoEXT32; + VkBool32 legacyDithering; +} VkPhysicalDeviceLegacyDitheringFeaturesEXT32;

-typedef struct VkPipelineColorWriteCreateInfoEXT32 +typedef struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t attachmentCount; - PTR32 pColorWriteEnables; -} VkPipelineColorWriteCreateInfoEXT32; + VkBool32 legacyVertexAttributes; +} VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32;

-typedef struct VkPipelineColorBlendStateCreateInfo32 +typedef struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkPipelineColorBlendStateCreateFlags flags; - VkBool32 logicOpEnable; - VkLogicOp logicOp; - uint32_t attachmentCount; - PTR32 pAttachments; - float blendConstants[4]; -} VkPipelineColorBlendStateCreateInfo32; + VkBool32 nativeUnalignedPerformance; +} VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32;

-typedef struct VkPipelineDynamicStateCreateInfo32 +typedef struct VkPhysicalDeviceLineRasterizationFeatures32 { VkStructureType sType; PTR32 pNext; - VkPipelineDynamicStateCreateFlags flags; - uint32_t dynamicStateCount; - PTR32 pDynamicStates; -} VkPipelineDynamicStateCreateInfo32; + VkBool32 rectangularLines; + VkBool32 bresenhamLines; + VkBool32 smoothLines; + VkBool32 stippledRectangularLines; + VkBool32 stippledBresenhamLines; + VkBool32 stippledSmoothLines; +} VkPhysicalDeviceLineRasterizationFeatures32; +typedef VkPhysicalDeviceLineRasterizationFeatures32 VkPhysicalDeviceLineRasterizationFeaturesKHR32; +typedef VkPhysicalDeviceLineRasterizationFeatures32 VkPhysicalDeviceLineRasterizationFeaturesEXT32;

-typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV32 +typedef struct VkPhysicalDeviceLineRasterizationProperties32 { VkStructureType sType; PTR32 pNext; - uint32_t groupCount; - PTR32 pGroups; - uint32_t pipelineCount; - PTR32 pPipelines; -} VkGraphicsPipelineShaderGroupsCreateInfoNV32; + uint32_t lineSubPixelPrecisionBits; +} VkPhysicalDeviceLineRasterizationProperties32; +typedef VkPhysicalDeviceLineRasterizationProperties32 VkPhysicalDeviceLineRasterizationPropertiesKHR32; +typedef VkPhysicalDeviceLineRasterizationProperties32 VkPhysicalDeviceLineRasterizationPropertiesEXT32;

-typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT32 +typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkPipelineDiscardRectangleStateCreateFlagsEXT flags; - VkDiscardRectangleModeEXT discardRectangleMode; - uint32_t discardRectangleCount; - PTR32 pDiscardRectangles; -} VkPipelineDiscardRectangleStateCreateInfoEXT32; + VkBool32 linearColorAttachment; +} VkPhysicalDeviceLinearColorAttachmentFeaturesNV32;

-typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 +typedef struct VkPhysicalDeviceMaintenance3Properties32 { VkStructureType sType; PTR32 pNext; - VkBool32 representativeFragmentTestEnable; -} VkPipelineRepresentativeFragmentTestStateCreateInfoNV32; + uint32_t maxPerSetDescriptors; + VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize; +} VkPhysicalDeviceMaintenance3Properties32; +typedef VkPhysicalDeviceMaintenance3Properties32 VkPhysicalDeviceMaintenance3PropertiesKHR32;

-typedef struct VkPipelineLibraryCreateInfoKHR32 +typedef struct VkPhysicalDeviceMaintenance4Features32 { VkStructureType sType; PTR32 pNext; - uint32_t libraryCount; - PTR32 pLibraries; -} VkPipelineLibraryCreateInfoKHR32; + VkBool32 maintenance4; +} VkPhysicalDeviceMaintenance4Features32; +typedef VkPhysicalDeviceMaintenance4Features32 VkPhysicalDeviceMaintenance4FeaturesKHR32;

-typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR32 +typedef struct VkPhysicalDeviceMaintenance4Properties32 { VkStructureType sType; PTR32 pNext; - VkExtent2D fragmentSize; - VkFragmentShadingRateCombinerOpKHR combinerOps[2]; -} VkPipelineFragmentShadingRateStateCreateInfoKHR32; + VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize; +} VkPhysicalDeviceMaintenance4Properties32; +typedef VkPhysicalDeviceMaintenance4Properties32 VkPhysicalDeviceMaintenance4PropertiesKHR32;

-typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 +typedef struct VkPhysicalDeviceMaintenance5Features32 { VkStructureType sType; PTR32 pNext; - VkFragmentShadingRateTypeNV shadingRateType; - VkFragmentShadingRateNV shadingRate; - VkFragmentShadingRateCombinerOpKHR combinerOps[2]; -} VkPipelineFragmentShadingRateEnumStateCreateInfoNV32; + VkBool32 maintenance5; +} VkPhysicalDeviceMaintenance5Features32; +typedef VkPhysicalDeviceMaintenance5Features32 VkPhysicalDeviceMaintenance5FeaturesKHR32;

-typedef struct VkPipelineRenderingCreateInfo32 +typedef struct VkPhysicalDeviceMaintenance5Properties32 { VkStructureType sType; PTR32 pNext; - uint32_t viewMask; - uint32_t colorAttachmentCount; - PTR32 pColorAttachmentFormats; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; -} VkPipelineRenderingCreateInfo32; -typedef VkPipelineRenderingCreateInfo32 VkPipelineRenderingCreateInfoKHR32; + VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; + VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; + VkBool32 depthStencilSwizzleOneSupport; + VkBool32 polygonModePointSize; + VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; + VkBool32 nonStrictWideLinesUseParallelogram; +} VkPhysicalDeviceMaintenance5Properties32; +typedef VkPhysicalDeviceMaintenance5Properties32 VkPhysicalDeviceMaintenance5PropertiesKHR32;

-typedef struct VkGraphicsPipelineLibraryCreateInfoEXT32 +typedef struct VkPhysicalDeviceMaintenance6Features32 { VkStructureType sType; PTR32 pNext; - VkGraphicsPipelineLibraryFlagsEXT flags; -} VkGraphicsPipelineLibraryCreateInfoEXT32; + VkBool32 maintenance6; +} VkPhysicalDeviceMaintenance6Features32; +typedef VkPhysicalDeviceMaintenance6Features32 VkPhysicalDeviceMaintenance6FeaturesKHR32;

-typedef struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32 +typedef struct VkPhysicalDeviceMaintenance6Properties32 { VkStructureType sType; PTR32 pNext; - uint32_t maxFragmentDensityMapLayers; -} VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32; + VkBool32 blockTexelViewCompatibleMultipleLayers; + uint32_t maxCombinedImageSamplerDescriptorCount; + VkBool32 fragmentShadingRateClampCombinerInputs; +} VkPhysicalDeviceMaintenance6Properties32; +typedef VkPhysicalDeviceMaintenance6Properties32 VkPhysicalDeviceMaintenance6PropertiesKHR32;

-typedef struct VkGraphicsPipelineCreateInfo32 +typedef struct VkPhysicalDeviceMaintenance8FeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - PTR32 pStages; - PTR32 pVertexInputState; - PTR32 pInputAssemblyState; - PTR32 pTessellationState; - PTR32 pViewportState; - PTR32 pRasterizationState; - PTR32 pMultisampleState; - PTR32 pDepthStencilState; - PTR32 pColorBlendState; - PTR32 pDynamicState; - VkPipelineLayout DECLSPEC_ALIGN(8) layout; - VkRenderPass DECLSPEC_ALIGN(8) renderPass; - uint32_t subpass; - VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle; - int32_t basePipelineIndex; -} VkGraphicsPipelineCreateInfo32; + VkBool32 maintenance8; +} VkPhysicalDeviceMaintenance8FeaturesKHR32;

-typedef struct VkDedicatedAllocationImageCreateInfoNV32 +typedef struct VkPhysicalDeviceMaintenance9FeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 dedicatedAllocation; -} VkDedicatedAllocationImageCreateInfoNV32; + VkBool32 maintenance9; +} VkPhysicalDeviceMaintenance9FeaturesKHR32;

-typedef struct VkExternalMemoryImageCreateInfo32 +typedef struct VkPhysicalDeviceMaintenance9PropertiesKHR32 { VkStructureType sType; PTR32 pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExternalMemoryImageCreateInfo32; -typedef VkExternalMemoryImageCreateInfo32 VkExternalMemoryImageCreateInfoKHR32; + VkBool32 image2DViewOf3DSparse; + VkDefaultVertexAttributeValueKHR defaultVertexAttributeValue; +} VkPhysicalDeviceMaintenance9PropertiesKHR32;

-typedef struct VkImageSwapchainCreateInfoKHR32 +typedef struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; -} VkImageSwapchainCreateInfoKHR32; + VkBool32 memoryMapPlaced; + VkBool32 memoryMapRangePlaced; + VkBool32 memoryUnmapReserve; +} VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32;

-typedef struct VkImageFormatListCreateInfo32 +typedef struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t viewFormatCount; - PTR32 pViewFormats; -} VkImageFormatListCreateInfo32; -typedef VkImageFormatListCreateInfo32 VkImageFormatListCreateInfoKHR32; + VkDeviceSize DECLSPEC_ALIGN(8) minPlacedMemoryMapAlignment; +} VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32;

-typedef struct VkImageStencilUsageCreateInfo32 +typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkImageUsageFlags stencilUsage; -} VkImageStencilUsageCreateInfo32; -typedef VkImageStencilUsageCreateInfo32 VkImageStencilUsageCreateInfoEXT32; + VkDeviceSize DECLSPEC_ALIGN(8) heapBudget[VK_MAX_MEMORY_HEAPS]; + VkDeviceSize DECLSPEC_ALIGN(8) heapUsage[VK_MAX_MEMORY_HEAPS]; +} VkPhysicalDeviceMemoryBudgetPropertiesEXT32;

-typedef struct VkImageCompressionControlEXT32 +typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkImageCompressionFlagsEXT flags; - uint32_t compressionControlPlaneCount; - PTR32 pFixedRateFlags; -} VkImageCompressionControlEXT32; + VkBool32 memoryDecompression; +} VkPhysicalDeviceMemoryDecompressionFeaturesNV32;

-typedef struct VkOpticalFlowImageFormatInfoNV32 +typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkOpticalFlowUsageFlagsNV usage; -} VkOpticalFlowImageFormatInfoNV32; + VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethods; + uint64_t DECLSPEC_ALIGN(8) maxDecompressionIndirectCount; +} VkPhysicalDeviceMemoryDecompressionPropertiesNV32;

-typedef struct VkImageAlignmentControlCreateInfoMESA32 +typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t maximumRequestedAlignment; -} VkImageAlignmentControlCreateInfoMESA32; + VkBool32 memoryPriority; +} VkPhysicalDeviceMemoryPriorityFeaturesEXT32;

-typedef struct VkImageCreateInfo32 +typedef struct VkPhysicalDeviceMemoryProperties232 { VkStructureType sType; PTR32 pNext; - VkImageCreateFlags flags; - VkImageType imageType; - VkFormat format; - VkExtent3D extent; - uint32_t mipLevels; - uint32_t arrayLayers; - VkSampleCountFlagBits samples; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - PTR32 pQueueFamilyIndices; - VkImageLayout initialLayout; -} VkImageCreateInfo32; + VkPhysicalDeviceMemoryProperties32 DECLSPEC_ALIGN(8) memoryProperties; +} VkPhysicalDeviceMemoryProperties232; +typedef VkPhysicalDeviceMemoryProperties232 VkPhysicalDeviceMemoryProperties2KHR32;

-typedef struct VkImageViewUsageCreateInfo32 +typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkImageUsageFlags usage; -} VkImageViewUsageCreateInfo32; -typedef VkImageViewUsageCreateInfo32 VkImageViewUsageCreateInfoKHR32; + VkBool32 taskShader; + VkBool32 meshShader; + VkBool32 multiviewMeshShader; + VkBool32 primitiveFragmentShadingRateMeshShader; + VkBool32 meshShaderQueries; +} VkPhysicalDeviceMeshShaderFeaturesEXT32;

-typedef struct VkImageViewSlicedCreateInfoEXT32 +typedef struct VkPhysicalDeviceMeshShaderFeaturesNV32 { VkStructureType sType; PTR32 pNext; - uint32_t sliceOffset; - uint32_t sliceCount; -} VkImageViewSlicedCreateInfoEXT32; + VkBool32 taskShader; + VkBool32 meshShader; +} VkPhysicalDeviceMeshShaderFeaturesNV32;

-typedef struct VkSamplerYcbcrConversionInfo32 +typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) conversion; -} VkSamplerYcbcrConversionInfo32; -typedef VkSamplerYcbcrConversionInfo32 VkSamplerYcbcrConversionInfoKHR32; + uint32_t maxTaskWorkGroupTotalCount; + uint32_t maxTaskWorkGroupCount[3]; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskPayloadSize; + uint32_t maxTaskSharedMemorySize; + uint32_t maxTaskPayloadAndSharedMemorySize; + uint32_t maxMeshWorkGroupTotalCount; + uint32_t maxMeshWorkGroupCount[3]; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshSharedMemorySize; + uint32_t maxMeshPayloadAndSharedMemorySize; + uint32_t maxMeshOutputMemorySize; + uint32_t maxMeshPayloadAndOutputMemorySize; + uint32_t maxMeshOutputComponents; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshOutputLayers; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; + uint32_t maxPreferredTaskWorkGroupInvocations; + uint32_t maxPreferredMeshWorkGroupInvocations; + VkBool32 prefersLocalInvocationVertexOutput; + VkBool32 prefersLocalInvocationPrimitiveOutput; + VkBool32 prefersCompactVertexOutput; + VkBool32 prefersCompactPrimitiveOutput; +} VkPhysicalDeviceMeshShaderPropertiesEXT32;

-typedef struct VkImageViewASTCDecodeModeEXT32 +typedef struct VkPhysicalDeviceMeshShaderPropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkFormat decodeMode; -} VkImageViewASTCDecodeModeEXT32; + uint32_t maxDrawMeshTasksCount; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskTotalMemorySize; + uint32_t maxTaskOutputCount; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshTotalMemorySize; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; +} VkPhysicalDeviceMeshShaderPropertiesNV32;

-typedef struct VkImageViewMinLodCreateInfoEXT32 +typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - float minLod; -} VkImageViewMinLodCreateInfoEXT32; + VkBool32 multiDraw; +} VkPhysicalDeviceMultiDrawFeaturesEXT32;

-typedef struct VkImageViewSampleWeightCreateInfoQCOM32 +typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkOffset2D filterCenter; - VkExtent2D filterSize; - uint32_t numPhases; -} VkImageViewSampleWeightCreateInfoQCOM32; + uint32_t maxMultiDrawCount; +} VkPhysicalDeviceMultiDrawPropertiesEXT32;

-typedef struct VkImageViewCreateInfo32 +typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkImageViewCreateFlags flags; - VkImage DECLSPEC_ALIGN(8) image; - VkImageViewType viewType; - VkFormat format; - VkComponentMapping components; - VkImageSubresourceRange subresourceRange; -} VkImageViewCreateInfo32; + VkBool32 multisampledRenderToSingleSampled; +} VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32;

-typedef union VkIndirectCommandsTokenDataEXT32 +typedef struct VkPhysicalDeviceMultiviewFeatures32 { - PTR32 pPushConstant; - PTR32 pVertexBuffer; - PTR32 pIndexBuffer; - PTR32 pExecutionSet; -} VkIndirectCommandsTokenDataEXT32; + VkStructureType sType; + PTR32 pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} VkPhysicalDeviceMultiviewFeatures32; +typedef VkPhysicalDeviceMultiviewFeatures32 VkPhysicalDeviceMultiviewFeaturesKHR32;

-typedef struct VkIndirectCommandsLayoutTokenEXT32 +typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 { VkStructureType sType; PTR32 pNext; - VkIndirectCommandsTokenTypeEXT type; - VkIndirectCommandsTokenDataEXT32 data; - uint32_t offset; -} VkIndirectCommandsLayoutTokenEXT32; + VkBool32 multiviewPerViewRenderAreas; +} VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32;

-typedef struct VkIndirectCommandsLayoutCreateInfoEXT32 +typedef struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 { VkStructureType sType; PTR32 pNext; - VkIndirectCommandsLayoutUsageFlagsEXT flags; - VkShaderStageFlags shaderStages; - uint32_t indirectStride; - VkPipelineLayout DECLSPEC_ALIGN(8) pipelineLayout; - uint32_t tokenCount; - PTR32 pTokens; -} VkIndirectCommandsLayoutCreateInfoEXT32; + VkBool32 multiviewPerViewViewports; +} VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32;

-typedef struct VkIndirectCommandsLayoutTokenNV32 +typedef struct VkPhysicalDeviceMultiviewProperties32 { VkStructureType sType; PTR32 pNext; - VkIndirectCommandsTokenTypeNV tokenType; - uint32_t stream; - uint32_t offset; - uint32_t vertexBindingUnit; - VkBool32 vertexDynamicStride; - VkPipelineLayout DECLSPEC_ALIGN(8) pushconstantPipelineLayout; - VkShaderStageFlags pushconstantShaderStageFlags; - uint32_t pushconstantOffset; - uint32_t pushconstantSize; - VkIndirectStateFlagsNV indirectStateFlags; - uint32_t indexTypeCount; - PTR32 pIndexTypes; - PTR32 pIndexTypeValues; -} VkIndirectCommandsLayoutTokenNV32; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; +} VkPhysicalDeviceMultiviewProperties32; +typedef VkPhysicalDeviceMultiviewProperties32 VkPhysicalDeviceMultiviewPropertiesKHR32;

-typedef struct VkIndirectCommandsLayoutCreateInfoNV32 +typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkIndirectCommandsLayoutUsageFlagsNV flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t tokenCount; - PTR32 pTokens; - uint32_t streamCount; - PTR32 pStreamStrides; -} VkIndirectCommandsLayoutCreateInfoNV32; + VkBool32 mutableDescriptorType; +} VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32; +typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE32;

-typedef struct VkIndirectExecutionSetPipelineInfoEXT32 +typedef struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkPipeline DECLSPEC_ALIGN(8) initialPipeline; - uint32_t maxPipelineCount; -} VkIndirectExecutionSetPipelineInfoEXT32; + VkBool32 nestedCommandBuffer; + VkBool32 nestedCommandBufferRendering; + VkBool32 nestedCommandBufferSimultaneousUse; +} VkPhysicalDeviceNestedCommandBufferFeaturesEXT32;

-typedef struct VkIndirectExecutionSetShaderLayoutInfoEXT32 +typedef struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t setLayoutCount; - PTR32 pSetLayouts; -} VkIndirectExecutionSetShaderLayoutInfoEXT32; + uint32_t maxCommandBufferNestingLevel; +} VkPhysicalDeviceNestedCommandBufferPropertiesEXT32;

-typedef struct VkIndirectExecutionSetShaderInfoEXT32 +typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t shaderCount; - PTR32 pInitialShaders; - PTR32 pSetLayoutInfos; - uint32_t maxShaderCount; - uint32_t pushConstantRangeCount; - PTR32 pPushConstantRanges; -} VkIndirectExecutionSetShaderInfoEXT32; + VkBool32 nonSeamlessCubeMap; +} VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32;

-typedef union VkIndirectExecutionSetInfoEXT32 +typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT32 { - PTR32 pPipelineInfo; - PTR32 pShaderInfo; -} VkIndirectExecutionSetInfoEXT32; + VkStructureType sType; + PTR32 pNext; + VkBool32 micromap; + VkBool32 micromapCaptureReplay; + VkBool32 micromapHostCommands; +} VkPhysicalDeviceOpacityMicromapFeaturesEXT32;

-typedef struct VkIndirectExecutionSetCreateInfoEXT32 +typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkIndirectExecutionSetInfoTypeEXT type; - VkIndirectExecutionSetInfoEXT32 info; -} VkIndirectExecutionSetCreateInfoEXT32; + uint32_t maxOpacity2StateSubdivisionLevel; + uint32_t maxOpacity4StateSubdivisionLevel; +} VkPhysicalDeviceOpacityMicromapPropertiesEXT32;

-typedef struct VkLayerSettingEXT32 +typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV32 { - PTR32 pLayerName; - PTR32 pSettingName; - VkLayerSettingTypeEXT type; - uint32_t valueCount; - PTR32 pValues; -} VkLayerSettingEXT32; + VkStructureType sType; + PTR32 pNext; + VkBool32 opticalFlow; +} VkPhysicalDeviceOpticalFlowFeaturesNV32;

-typedef struct VkApplicationInfo32 +typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV32 { VkStructureType sType; PTR32 pNext; - PTR32 pApplicationName; - uint32_t applicationVersion; - PTR32 pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; -} VkApplicationInfo32; + VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes; + VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes; + VkBool32 hintSupported; + VkBool32 costSupported; + VkBool32 bidirectionalFlowSupported; + VkBool32 globalFlowSupported; + uint32_t minWidth; + uint32_t minHeight; + uint32_t maxWidth; + uint32_t maxHeight; + uint32_t maxNumRegionsOfInterest; +} VkPhysicalDeviceOpticalFlowPropertiesNV32;

-typedef struct VkValidationFlagsEXT32 +typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t disabledValidationCheckCount; - PTR32 pDisabledValidationChecks; -} VkValidationFlagsEXT32; + uint32_t pciDomain; + uint32_t pciBus; + uint32_t pciDevice; + uint32_t pciFunction; +} VkPhysicalDevicePCIBusInfoPropertiesEXT32;

-typedef struct VkValidationFeaturesEXT32 +typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t enabledValidationFeatureCount; - PTR32 pEnabledValidationFeatures; - uint32_t disabledValidationFeatureCount; - PTR32 pDisabledValidationFeatures; -} VkValidationFeaturesEXT32; + VkBool32 pageableDeviceLocalMemory; +} VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32;

-typedef struct VkLayerSettingsCreateInfoEXT32 +typedef struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 { VkStructureType sType; PTR32 pNext; - uint32_t settingCount; - PTR32 pSettings; -} VkLayerSettingsCreateInfoEXT32; + VkBool32 partitionedAccelerationStructure; +} VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32;

-typedef struct VkInstanceCreateInfo32 +typedef struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkInstanceCreateFlags flags; - PTR32 pApplicationInfo; - uint32_t enabledLayerCount; - PTR32 ppEnabledLayerNames; - uint32_t enabledExtensionCount; - PTR32 ppEnabledExtensionNames; -} VkInstanceCreateInfo32; + uint32_t maxPartitionCount; +} VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV32;

-typedef struct VkMicromapCreateInfoEXT32 +typedef struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkMicromapCreateFlagsEXT createFlags; - VkBuffer DECLSPEC_ALIGN(8) buffer; - VkDeviceSize DECLSPEC_ALIGN(8) offset; - VkDeviceSize DECLSPEC_ALIGN(8) size; - VkMicromapTypeEXT type; - VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress; -} VkMicromapCreateInfoEXT32; + VkBool32 perStageDescriptorSet; + VkBool32 dynamicPipelineLayout; +} VkPhysicalDevicePerStageDescriptorSetFeaturesNV32;

-typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV32 +typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t id; - uint32_t size; - PTR32 pPrivateData; -} VkOpticalFlowSessionCreatePrivateDataInfoNV32; + VkBool32 performanceCounterQueryPools; + VkBool32 performanceCounterMultipleQueryPools; +} VkPhysicalDevicePerformanceQueryFeaturesKHR32;

-typedef struct VkOpticalFlowSessionCreateInfoNV32 +typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t width; - uint32_t height; - VkFormat imageFormat; - VkFormat flowVectorFormat; - VkFormat costFormat; - VkOpticalFlowGridSizeFlagsNV outputGridSize; - VkOpticalFlowGridSizeFlagsNV hintGridSize; - VkOpticalFlowPerformanceLevelNV performanceLevel; - VkOpticalFlowSessionCreateFlagsNV flags; -} VkOpticalFlowSessionCreateInfoNV32; + VkBool32 allowCommandBufferQueryCopies; +} VkPhysicalDevicePerformanceQueryPropertiesKHR32;

-typedef struct VkPipelineBinaryKeyKHR32 +typedef struct VkPhysicalDevicePipelineBinaryFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t keySize; - uint8_t key[VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR]; -} VkPipelineBinaryKeyKHR32; + VkBool32 pipelineBinaries; +} VkPhysicalDevicePipelineBinaryFeaturesKHR32;

-typedef struct VkPipelineBinaryDataKHR32 +typedef struct VkPhysicalDevicePipelineBinaryPropertiesKHR32 { - PTR32 dataSize; - PTR32 pData; -} VkPipelineBinaryDataKHR32; + VkStructureType sType; + PTR32 pNext; + VkBool32 pipelineBinaryInternalCache; + VkBool32 pipelineBinaryInternalCacheControl; + VkBool32 pipelineBinaryPrefersInternalCache; + VkBool32 pipelineBinaryPrecompiledInternalCache; + VkBool32 pipelineBinaryCompressedData; +} VkPhysicalDevicePipelineBinaryPropertiesKHR32;

-typedef struct VkPipelineBinaryKeysAndDataKHR32 +typedef struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 { - uint32_t binaryCount; - PTR32 pPipelineBinaryKeys; - PTR32 pPipelineBinaryData; -} VkPipelineBinaryKeysAndDataKHR32; + VkStructureType sType; + PTR32 pNext; + VkBool32 pipelineCacheIncrementalMode; +} VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32;

-typedef struct VkPipelineCreateInfoKHR32 +typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures32 { VkStructureType sType; PTR32 pNext; -} VkPipelineCreateInfoKHR32; + VkBool32 pipelineCreationCacheControl; +} VkPhysicalDevicePipelineCreationCacheControlFeatures32; +typedef VkPhysicalDevicePipelineCreationCacheControlFeatures32 VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT32;

-typedef struct VkPipelineBinaryCreateInfoKHR32 +typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - PTR32 pKeysAndDataInfo; - VkPipeline DECLSPEC_ALIGN(8) pipeline; - PTR32 pPipelineCreateInfo; -} VkPipelineBinaryCreateInfoKHR32; + VkBool32 pipelineExecutableInfo; +} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32;

-typedef struct VkPipelineBinaryHandlesInfoKHR32 +typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t pipelineBinaryCount; - PTR32 pPipelineBinaries; -} VkPipelineBinaryHandlesInfoKHR32; + VkBool32 pipelineLibraryGroupHandles; +} VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32;

-typedef struct VkPipelineCacheCreateInfo32 +typedef struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 { VkStructureType sType; PTR32 pNext; - VkPipelineCacheCreateFlags flags; - PTR32 initialDataSize; - PTR32 pInitialData; -} VkPipelineCacheCreateInfo32; + VkBool32 pipelineOpacityMicromap; +} VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32;

-typedef struct VkPrivateDataSlotCreateInfo32 +typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkPrivateDataSlotCreateFlags flags; -} VkPrivateDataSlotCreateInfo32; -typedef VkPrivateDataSlotCreateInfo32 VkPrivateDataSlotCreateInfoEXT32; + VkBool32 pipelinePropertiesIdentifier; +} VkPhysicalDevicePipelinePropertiesFeaturesEXT32;

-typedef struct VkQueryPoolPerformanceCreateInfoKHR32 +typedef struct VkPhysicalDevicePipelineProtectedAccessFeatures32 { VkStructureType sType; PTR32 pNext; - uint32_t queueFamilyIndex; - uint32_t counterIndexCount; - PTR32 pCounterIndices; -} VkQueryPoolPerformanceCreateInfoKHR32; + VkBool32 pipelineProtectedAccess; +} VkPhysicalDevicePipelineProtectedAccessFeatures32; +typedef VkPhysicalDevicePipelineProtectedAccessFeatures32 VkPhysicalDevicePipelineProtectedAccessFeaturesEXT32;

-typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL32 +typedef struct VkPhysicalDevicePipelineRobustnessFeatures32 { VkStructureType sType; PTR32 pNext; - VkQueryPoolSamplingModeINTEL performanceCountersSampling; -} VkQueryPoolPerformanceQueryCreateInfoINTEL32; -typedef VkQueryPoolPerformanceQueryCreateInfoINTEL32 VkQueryPoolCreateInfoINTEL32; + VkBool32 pipelineRobustness; +} VkPhysicalDevicePipelineRobustnessFeatures32; +typedef VkPhysicalDevicePipelineRobustnessFeatures32 VkPhysicalDevicePipelineRobustnessFeaturesEXT32;

-typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32 +typedef struct VkPhysicalDevicePipelineRobustnessProperties32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags; -} VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32; + VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers; + VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers; + VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs; + VkPipelineRobustnessImageBehavior defaultRobustnessImages; +} VkPhysicalDevicePipelineRobustnessProperties32; +typedef VkPhysicalDevicePipelineRobustnessProperties32 VkPhysicalDevicePipelineRobustnessPropertiesEXT32;

-typedef struct VkQueryPoolCreateInfo32 +typedef struct VkPhysicalDevicePointClippingProperties32 { VkStructureType sType; PTR32 pNext; - VkQueryPoolCreateFlags flags; - VkQueryType queryType; - uint32_t queryCount; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkQueryPoolCreateInfo32; + VkPointClippingBehavior pointClippingBehavior; +} VkPhysicalDevicePointClippingProperties32; +typedef VkPhysicalDevicePointClippingProperties32 VkPhysicalDevicePointClippingPropertiesKHR32;

-typedef struct VkRayTracingShaderGroupCreateInfoKHR32 +typedef struct VkPhysicalDevicePresentBarrierFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkRayTracingShaderGroupTypeKHR type; - uint32_t generalShader; - uint32_t closestHitShader; - uint32_t anyHitShader; - uint32_t intersectionShader; - PTR32 pShaderGroupCaptureReplayHandle; -} VkRayTracingShaderGroupCreateInfoKHR32; + VkBool32 presentBarrier; +} VkPhysicalDevicePresentBarrierFeaturesNV32;

-typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR32 +typedef struct VkPhysicalDevicePresentId2FeaturesKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t maxPipelineRayPayloadSize; - uint32_t maxPipelineRayHitAttributeSize; -} VkRayTracingPipelineInterfaceCreateInfoKHR32; + VkBool32 presentId2; +} VkPhysicalDevicePresentId2FeaturesKHR32;

-typedef struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32 +typedef struct VkPhysicalDevicePresentIdFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 allowClusterAccelerationStructure; -} VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32; + VkBool32 presentId; +} VkPhysicalDevicePresentIdFeaturesKHR32;

-typedef struct VkRayTracingPipelineCreateInfoKHR32 +typedef struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - PTR32 pStages; - uint32_t groupCount; - PTR32 pGroups; - uint32_t maxPipelineRayRecursionDepth; - PTR32 pLibraryInfo; - PTR32 pLibraryInterface; - PTR32 pDynamicState; - VkPipelineLayout DECLSPEC_ALIGN(8) layout; - VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle; - int32_t basePipelineIndex; -} VkRayTracingPipelineCreateInfoKHR32; + VkBool32 presentModeFifoLatestReady; +} VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32; +typedef VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT32;

-typedef struct VkRayTracingShaderGroupCreateInfoNV32 +typedef struct VkPhysicalDevicePresentWait2FeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkRayTracingShaderGroupTypeKHR type; - uint32_t generalShader; - uint32_t closestHitShader; - uint32_t anyHitShader; - uint32_t intersectionShader; -} VkRayTracingShaderGroupCreateInfoNV32; + VkBool32 presentWait2; +} VkPhysicalDevicePresentWait2FeaturesKHR32;

-typedef struct VkRayTracingPipelineCreateInfoNV32 +typedef struct VkPhysicalDevicePresentWaitFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - PTR32 pStages; - uint32_t groupCount; - PTR32 pGroups; - uint32_t maxRecursionDepth; - VkPipelineLayout DECLSPEC_ALIGN(8) layout; - VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle; - int32_t basePipelineIndex; -} VkRayTracingPipelineCreateInfoNV32; + VkBool32 presentWait; +} VkPhysicalDevicePresentWaitFeaturesKHR32;

-typedef struct VkSubpassDescription32 +typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 { - VkSubpassDescriptionFlags flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t inputAttachmentCount; - PTR32 pInputAttachments; - uint32_t colorAttachmentCount; - PTR32 pColorAttachments; - PTR32 pResolveAttachments; - PTR32 pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - PTR32 pPreserveAttachments; -} VkSubpassDescription32; + VkStructureType sType; + PTR32 pNext; + VkBool32 primitiveTopologyListRestart; + VkBool32 primitiveTopologyPatchListRestart; +} VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32;

-typedef struct VkRenderPassMultiviewCreateInfo32 +typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t subpassCount; - PTR32 pViewMasks; - uint32_t dependencyCount; - PTR32 pViewOffsets; - uint32_t correlationMaskCount; - PTR32 pCorrelationMasks; -} VkRenderPassMultiviewCreateInfo32; -typedef VkRenderPassMultiviewCreateInfo32 VkRenderPassMultiviewCreateInfoKHR32; + VkBool32 primitivesGeneratedQuery; + VkBool32 primitivesGeneratedQueryWithRasterizerDiscard; + VkBool32 primitivesGeneratedQueryWithNonZeroStreams; +} VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32;

-typedef struct VkRenderPassInputAttachmentAspectCreateInfo32 +typedef struct VkPhysicalDevicePrivateDataFeatures32 { VkStructureType sType; PTR32 pNext; - uint32_t aspectReferenceCount; - PTR32 pAspectReferences; -} VkRenderPassInputAttachmentAspectCreateInfo32; -typedef VkRenderPassInputAttachmentAspectCreateInfo32 VkRenderPassInputAttachmentAspectCreateInfoKHR32; + VkBool32 privateData; +} VkPhysicalDevicePrivateDataFeatures32; +typedef VkPhysicalDevicePrivateDataFeatures32 VkPhysicalDevicePrivateDataFeaturesEXT32;

-typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT32 +typedef struct VkPhysicalDeviceProtectedMemoryFeatures32 { VkStructureType sType; PTR32 pNext; - VkAttachmentReference fragmentDensityMapAttachment; -} VkRenderPassFragmentDensityMapCreateInfoEXT32; + VkBool32 protectedMemory; +} VkPhysicalDeviceProtectedMemoryFeatures32;

-typedef struct VkRenderPassCreateInfo32 +typedef struct VkPhysicalDeviceProtectedMemoryProperties32 { VkStructureType sType; PTR32 pNext; - VkRenderPassCreateFlags flags; - uint32_t attachmentCount; - PTR32 pAttachments; - uint32_t subpassCount; - PTR32 pSubpasses; - uint32_t dependencyCount; - PTR32 pDependencies; -} VkRenderPassCreateInfo32; + VkBool32 protectedNoFault; +} VkPhysicalDeviceProtectedMemoryProperties32;

-typedef struct VkAttachmentDescriptionStencilLayout32 +typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkImageLayout stencilInitialLayout; - VkImageLayout stencilFinalLayout; -} VkAttachmentDescriptionStencilLayout32; -typedef VkAttachmentDescriptionStencilLayout32 VkAttachmentDescriptionStencilLayoutKHR32; + VkBool32 provokingVertexLast; + VkBool32 transformFeedbackPreservesProvokingVertex; +} VkPhysicalDeviceProvokingVertexFeaturesEXT32;

-typedef struct VkAttachmentDescription232 +typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkAttachmentDescriptionFlags flags; - VkFormat format; - VkSampleCountFlagBits samples; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkAttachmentLoadOp stencilLoadOp; - VkAttachmentStoreOp stencilStoreOp; - VkImageLayout initialLayout; - VkImageLayout finalLayout; -} VkAttachmentDescription232; -typedef VkAttachmentDescription232 VkAttachmentDescription2KHR32; + VkBool32 provokingVertexModePerPipeline; + VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex; +} VkPhysicalDeviceProvokingVertexPropertiesEXT32;

-typedef struct VkAttachmentReferenceStencilLayout32 +typedef struct VkPhysicalDevicePushDescriptorProperties32 { VkStructureType sType; PTR32 pNext; - VkImageLayout stencilLayout; -} VkAttachmentReferenceStencilLayout32; -typedef VkAttachmentReferenceStencilLayout32 VkAttachmentReferenceStencilLayoutKHR32; + uint32_t maxPushDescriptors; +} VkPhysicalDevicePushDescriptorProperties32; +typedef VkPhysicalDevicePushDescriptorProperties32 VkPhysicalDevicePushDescriptorPropertiesKHR32;

-typedef struct VkAttachmentReference232 +typedef struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32 { VkStructureType sType; PTR32 pNext; - uint32_t attachment; - VkImageLayout layout; - VkImageAspectFlags aspectMask; -} VkAttachmentReference232; -typedef VkAttachmentReference232 VkAttachmentReference2KHR32; + uint32_t queueFamilyIndex; + VkPhysicalDeviceDataGraphProcessingEngineTypeARM engineType; +} VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32;

-typedef struct VkSubpassDescriptionDepthStencilResolve32 +typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkResolveModeFlagBits depthResolveMode; - VkResolveModeFlagBits stencilResolveMode; - PTR32 pDepthStencilResolveAttachment; -} VkSubpassDescriptionDepthStencilResolve32; -typedef VkSubpassDescriptionDepthStencilResolve32 VkSubpassDescriptionDepthStencilResolveKHR32; + VkBool32 formatRgba10x6WithoutYCbCrSampler; +} VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32;

-typedef struct VkFragmentShadingRateAttachmentInfoKHR32 +typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - PTR32 pFragmentShadingRateAttachment; - VkExtent2D shadingRateAttachmentTexelSize; -} VkFragmentShadingRateAttachmentInfoKHR32; + VkBool32 rasterizationOrderColorAttachmentAccess; + VkBool32 rasterizationOrderDepthAttachmentAccess; + VkBool32 rasterizationOrderStencilAttachmentAccess; +} VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32; +typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM32;

-typedef struct VkRenderPassCreationControlEXT32 +typedef struct VkPhysicalDeviceRawAccessChainsFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 disallowMerging; -} VkRenderPassCreationControlEXT32; + VkBool32 shaderRawAccessChains; +} VkPhysicalDeviceRawAccessChainsFeaturesNV32;

-typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT32 +typedef struct VkPhysicalDeviceRayQueryFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - PTR32 pSubpassFeedback; -} VkRenderPassSubpassFeedbackCreateInfoEXT32; + VkBool32 rayQuery; +} VkPhysicalDeviceRayQueryFeaturesKHR32;

-typedef struct VkSubpassDescription232 +typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkSubpassDescriptionFlags flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t viewMask; - uint32_t inputAttachmentCount; - PTR32 pInputAttachments; - uint32_t colorAttachmentCount; - PTR32 pColorAttachments; - PTR32 pResolveAttachments; - PTR32 pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - PTR32 pPreserveAttachments; -} VkSubpassDescription232; -typedef VkSubpassDescription232 VkSubpassDescription2KHR32; + VkBool32 rayTracingInvocationReorder; +} VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32;

-typedef struct VkSubpassDependency232 +typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32 { VkStructureType sType; PTR32 pNext; - uint32_t srcSubpass; - uint32_t dstSubpass; - VkPipelineStageFlags srcStageMask; - VkPipelineStageFlags dstStageMask; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkDependencyFlags dependencyFlags; - int32_t viewOffset; -} VkSubpassDependency232; -typedef VkSubpassDependency232 VkSubpassDependency2KHR32; + VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint; +} VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32;

-typedef struct VkRenderPassCreationFeedbackCreateInfoEXT32 +typedef struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV32 { VkStructureType sType; PTR32 pNext; - PTR32 pRenderPassFeedback; -} VkRenderPassCreationFeedbackCreateInfoEXT32; + VkBool32 spheres; + VkBool32 linearSweptSpheres; +} VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV32;

-typedef struct VkRenderPassCreateInfo232 +typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkRenderPassCreateFlags flags; - uint32_t attachmentCount; - PTR32 pAttachments; - uint32_t subpassCount; - PTR32 pSubpasses; - uint32_t dependencyCount; - PTR32 pDependencies; - uint32_t correlatedViewMaskCount; - PTR32 pCorrelatedViewMasks; -} VkRenderPassCreateInfo232; -typedef VkRenderPassCreateInfo232 VkRenderPassCreateInfo2KHR32; + VkBool32 rayTracingMaintenance1; + VkBool32 rayTracingPipelineTraceRaysIndirect2; +} VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32;

-typedef struct VkSamplerReductionModeCreateInfo32 +typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkSamplerReductionMode reductionMode; -} VkSamplerReductionModeCreateInfo32; -typedef VkSamplerReductionModeCreateInfo32 VkSamplerReductionModeCreateInfoEXT32; + VkBool32 rayTracingMotionBlur; + VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect; +} VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32;

-typedef struct VkSamplerCustomBorderColorCreateInfoEXT32 +typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkClearColorValue customBorderColor; - VkFormat format; -} VkSamplerCustomBorderColorCreateInfoEXT32; + VkBool32 rayTracingPipeline; + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay; + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + VkBool32 rayTracingPipelineTraceRaysIndirect; + VkBool32 rayTraversalPrimitiveCulling; +} VkPhysicalDeviceRayTracingPipelineFeaturesKHR32;

-typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT32 +typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR32 { VkStructureType sType; PTR32 pNext; - VkComponentMapping components; - VkBool32 srgb; -} VkSamplerBorderColorComponentMappingCreateInfoEXT32; + uint32_t shaderGroupHandleSize; + uint32_t maxRayRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint32_t shaderGroupHandleCaptureReplaySize; + uint32_t maxRayDispatchInvocationCount; + uint32_t shaderGroupHandleAlignment; + uint32_t maxRayHitAttributeSize; +} VkPhysicalDeviceRayTracingPipelinePropertiesKHR32;

-typedef struct VkSamplerCubicWeightsCreateInfoQCOM32 +typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkCubicFilterWeightsQCOM cubicWeights; -} VkSamplerCubicWeightsCreateInfoQCOM32; + VkBool32 rayTracingPositionFetch; +} VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32;

-typedef struct VkSamplerBlockMatchWindowCreateInfoQCOM32 +typedef struct VkPhysicalDeviceRayTracingPropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkExtent2D windowExtent; - VkBlockMatchWindowCompareModeQCOM windowCompareMode; -} VkSamplerBlockMatchWindowCreateInfoQCOM32; + uint32_t shaderGroupHandleSize; + uint32_t maxRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint64_t DECLSPEC_ALIGN(8) maxGeometryCount; + uint64_t DECLSPEC_ALIGN(8) maxInstanceCount; + uint64_t DECLSPEC_ALIGN(8) maxTriangleCount; + uint32_t maxDescriptorSetAccelerationStructures; +} VkPhysicalDeviceRayTracingPropertiesNV32;

-typedef struct VkSamplerCreateInfo32 +typedef struct VkPhysicalDeviceRayTracingValidationFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkSamplerCreateFlags flags; - VkFilter magFilter; - VkFilter minFilter; - VkSamplerMipmapMode mipmapMode; - VkSamplerAddressMode addressModeU; - VkSamplerAddressMode addressModeV; - VkSamplerAddressMode addressModeW; - float mipLodBias; - VkBool32 anisotropyEnable; - float maxAnisotropy; - VkBool32 compareEnable; - VkCompareOp compareOp; - float minLod; - float maxLod; - VkBorderColor borderColor; - VkBool32 unnormalizedCoordinates; -} VkSamplerCreateInfo32; + VkBool32 rayTracingValidation; +} VkPhysicalDeviceRayTracingValidationFeaturesNV32;

-typedef struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM32 +typedef struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 { VkStructureType sType; PTR32 pNext; - VkBool32 enableYDegamma; - VkBool32 enableCbCrDegamma; -} VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM32; + VkBool32 relaxedLineRasterization; +} VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32;

-typedef struct VkSamplerYcbcrConversionCreateInfo32 +typedef struct VkPhysicalDeviceRenderPassStripedFeaturesARM32 { VkStructureType sType; PTR32 pNext; - VkFormat format; - VkSamplerYcbcrModelConversion ycbcrModel; - VkSamplerYcbcrRange ycbcrRange; - VkComponentMapping components; - VkChromaLocation xChromaOffset; - VkChromaLocation yChromaOffset; - VkFilter chromaFilter; - VkBool32 forceExplicitReconstruction; -} VkSamplerYcbcrConversionCreateInfo32; -typedef VkSamplerYcbcrConversionCreateInfo32 VkSamplerYcbcrConversionCreateInfoKHR32; + VkBool32 renderPassStriped; +} VkPhysicalDeviceRenderPassStripedFeaturesARM32;

-typedef struct VkExportSemaphoreCreateInfo32 +typedef struct VkPhysicalDeviceRenderPassStripedPropertiesARM32 { VkStructureType sType; PTR32 pNext; - VkExternalSemaphoreHandleTypeFlags handleTypes; -} VkExportSemaphoreCreateInfo32; -typedef VkExportSemaphoreCreateInfo32 VkExportSemaphoreCreateInfoKHR32; + VkExtent2D renderPassStripeGranularity; + uint32_t maxRenderPassStripes; +} VkPhysicalDeviceRenderPassStripedPropertiesARM32;

-typedef struct VkSemaphoreTypeCreateInfo32 +typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkSemaphoreType semaphoreType; - uint64_t DECLSPEC_ALIGN(8) initialValue; -} VkSemaphoreTypeCreateInfo32; -typedef VkSemaphoreTypeCreateInfo32 VkSemaphoreTypeCreateInfoKHR32; + VkBool32 representativeFragmentTest; +} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32;

-typedef struct VkQueryLowLatencySupportNV32 +typedef struct VkPhysicalDeviceRobustness2FeaturesKHR32 { VkStructureType sType; PTR32 pNext; - PTR32 pQueriedLowLatencyData; -} VkQueryLowLatencySupportNV32; + VkBool32 robustBufferAccess2; + VkBool32 robustImageAccess2; + VkBool32 nullDescriptor; +} VkPhysicalDeviceRobustness2FeaturesKHR32; +typedef VkPhysicalDeviceRobustness2FeaturesKHR32 VkPhysicalDeviceRobustness2FeaturesEXT32;

-typedef struct VkSemaphoreCreateInfo32 +typedef struct VkPhysicalDeviceRobustness2PropertiesKHR32 { VkStructureType sType; PTR32 pNext; - VkSemaphoreCreateFlags flags; -} VkSemaphoreCreateInfo32; + VkDeviceSize DECLSPEC_ALIGN(8) robustStorageBufferAccessSizeAlignment; + VkDeviceSize DECLSPEC_ALIGN(8) robustUniformBufferAccessSizeAlignment; +} VkPhysicalDeviceRobustness2PropertiesKHR32; +typedef VkPhysicalDeviceRobustness2PropertiesKHR32 VkPhysicalDeviceRobustness2PropertiesEXT32;

-typedef struct VkShaderCreateInfoEXT32 +typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkShaderCreateFlagsEXT flags; - VkShaderStageFlagBits stage; - VkShaderStageFlags nextStage; - VkShaderCodeTypeEXT codeType; - PTR32 codeSize; - PTR32 pCode; - PTR32 pName; - uint32_t setLayoutCount; - PTR32 pSetLayouts; - uint32_t pushConstantRangeCount; - PTR32 pPushConstantRanges; - PTR32 pSpecializationInfo; -} VkShaderCreateInfoEXT32; + VkSampleCountFlags sampleLocationSampleCounts; + VkExtent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + VkBool32 variableSampleLocations; +} VkPhysicalDeviceSampleLocationsPropertiesEXT32;

-typedef struct VkDeviceGroupSwapchainCreateInfoKHR32 +typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties32 { VkStructureType sType; PTR32 pNext; - VkDeviceGroupPresentModeFlagsKHR modes; -} VkDeviceGroupSwapchainCreateInfoKHR32; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} VkPhysicalDeviceSamplerFilterMinmaxProperties32; +typedef VkPhysicalDeviceSamplerFilterMinmaxProperties32 VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT32;

-typedef struct VkSwapchainPresentBarrierCreateInfoNV32 +typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures32 { VkStructureType sType; PTR32 pNext; - VkBool32 presentBarrierEnable; -} VkSwapchainPresentBarrierCreateInfoNV32; + VkBool32 samplerYcbcrConversion; +} VkPhysicalDeviceSamplerYcbcrConversionFeatures32; +typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures32 VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR32;

-typedef struct VkSwapchainPresentModesCreateInfoKHR32 +typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures32 { VkStructureType sType; PTR32 pNext; - uint32_t presentModeCount; - PTR32 pPresentModes; -} VkSwapchainPresentModesCreateInfoKHR32; -typedef VkSwapchainPresentModesCreateInfoKHR32 VkSwapchainPresentModesCreateInfoEXT32; + VkBool32 scalarBlockLayout; +} VkPhysicalDeviceScalarBlockLayoutFeatures32; +typedef VkPhysicalDeviceScalarBlockLayoutFeatures32 VkPhysicalDeviceScalarBlockLayoutFeaturesEXT32;

-typedef struct VkSwapchainPresentScalingCreateInfoKHR32 +typedef struct VkPhysicalDeviceSchedulingControlsFeaturesARM32 { VkStructureType sType; PTR32 pNext; - VkPresentScalingFlagsKHR scalingBehavior; - VkPresentGravityFlagsKHR presentGravityX; - VkPresentGravityFlagsKHR presentGravityY; -} VkSwapchainPresentScalingCreateInfoKHR32; -typedef VkSwapchainPresentScalingCreateInfoKHR32 VkSwapchainPresentScalingCreateInfoEXT32; + VkBool32 schedulingControls; +} VkPhysicalDeviceSchedulingControlsFeaturesARM32;

-typedef struct VkSwapchainLatencyCreateInfoNV32 +typedef struct VkPhysicalDeviceSchedulingControlsPropertiesARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 latencyModeEnable; -} VkSwapchainLatencyCreateInfoNV32; + VkPhysicalDeviceSchedulingControlsFlagsARM DECLSPEC_ALIGN(8) schedulingControlsFlags; +} VkPhysicalDeviceSchedulingControlsPropertiesARM32;

-typedef struct VkSwapchainCreateInfoKHR32 +typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 { VkStructureType sType; PTR32 pNext; - VkSwapchainCreateFlagsKHR flags; - VkSurfaceKHR DECLSPEC_ALIGN(8) surface; - uint32_t minImageCount; - VkFormat imageFormat; - VkColorSpaceKHR imageColorSpace; - VkExtent2D imageExtent; - uint32_t imageArrayLayers; - VkImageUsageFlags imageUsage; - VkSharingMode imageSharingMode; - uint32_t queueFamilyIndexCount; - PTR32 pQueueFamilyIndices; - VkSurfaceTransformFlagBitsKHR preTransform; - VkCompositeAlphaFlagBitsKHR compositeAlpha; - VkPresentModeKHR presentMode; - VkBool32 clipped; - VkSwapchainKHR DECLSPEC_ALIGN(8) oldSwapchain; -} VkSwapchainCreateInfoKHR32; + VkBool32 separateDepthStencilLayouts; +} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32; +typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR32;

-typedef struct VkExternalMemoryTensorCreateInfoARM32 +typedef struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExternalMemoryTensorCreateInfoARM32; + VkBool32 shaderFloat16VectorAtomics; +} VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32;

-typedef struct VkTensorCreateInfoARM32 +typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkTensorCreateFlagsARM DECLSPEC_ALIGN(8) flags; - PTR32 pDescription; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - PTR32 pQueueFamilyIndices; -} VkTensorCreateInfoARM32; + VkBool32 shaderBufferFloat16Atomics; + VkBool32 shaderBufferFloat16AtomicAdd; + VkBool32 shaderBufferFloat16AtomicMinMax; + VkBool32 shaderBufferFloat32AtomicMinMax; + VkBool32 shaderBufferFloat64AtomicMinMax; + VkBool32 shaderSharedFloat16Atomics; + VkBool32 shaderSharedFloat16AtomicAdd; + VkBool32 shaderSharedFloat16AtomicMinMax; + VkBool32 shaderSharedFloat32AtomicMinMax; + VkBool32 shaderSharedFloat64AtomicMinMax; + VkBool32 shaderImageFloat32AtomicMinMax; + VkBool32 sparseImageFloat32AtomicMinMax; +} VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32;

-typedef struct VkTensorViewCreateInfoARM32 +typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkTensorViewCreateFlagsARM DECLSPEC_ALIGN(8) flags; - VkTensorARM DECLSPEC_ALIGN(8) tensor; - VkFormat format; -} VkTensorViewCreateInfoARM32; + VkBool32 shaderBufferFloat32Atomics; + VkBool32 shaderBufferFloat32AtomicAdd; + VkBool32 shaderBufferFloat64Atomics; + VkBool32 shaderBufferFloat64AtomicAdd; + VkBool32 shaderSharedFloat32Atomics; + VkBool32 shaderSharedFloat32AtomicAdd; + VkBool32 shaderSharedFloat64Atomics; + VkBool32 shaderSharedFloat64AtomicAdd; + VkBool32 shaderImageFloat32Atomics; + VkBool32 shaderImageFloat32AtomicAdd; + VkBool32 sparseImageFloat32Atomics; + VkBool32 sparseImageFloat32AtomicAdd; +} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32;

-typedef struct VkValidationCacheCreateInfoEXT32 +typedef struct VkPhysicalDeviceShaderAtomicInt64Features32 { VkStructureType sType; PTR32 pNext; - VkValidationCacheCreateFlagsEXT flags; - PTR32 initialDataSize; - PTR32 pInitialData; -} VkValidationCacheCreateInfoEXT32; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; +} VkPhysicalDeviceShaderAtomicInt64Features32; +typedef VkPhysicalDeviceShaderAtomicInt64Features32 VkPhysicalDeviceShaderAtomicInt64FeaturesKHR32;

-typedef struct VkVideoEncodeH264SessionCreateInfoKHR32 +typedef struct VkPhysicalDeviceShaderBfloat16FeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 useMaxLevelIdc; - StdVideoH264LevelIdc maxLevelIdc; -} VkVideoEncodeH264SessionCreateInfoKHR32; + VkBool32 shaderBFloat16Type; + VkBool32 shaderBFloat16DotProduct; + VkBool32 shaderBFloat16CooperativeMatrix; +} VkPhysicalDeviceShaderBfloat16FeaturesKHR32;

-typedef struct VkVideoEncodeAV1SessionCreateInfoKHR32 +typedef struct VkPhysicalDeviceShaderClockFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 useMaxLevel; - StdVideoAV1Level maxLevel; -} VkVideoEncodeAV1SessionCreateInfoKHR32; + VkBool32 shaderSubgroupClock; + VkBool32 shaderDeviceClock; +} VkPhysicalDeviceShaderClockFeaturesKHR32;

-typedef struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR32 +typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode; -} VkVideoEncodeSessionIntraRefreshCreateInfoKHR32; + VkBool32 shaderCoreBuiltins; +} VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32;

-typedef struct VkVideoSessionCreateInfoKHR32 +typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32 { VkStructureType sType; PTR32 pNext; - uint32_t queueFamilyIndex; - VkVideoSessionCreateFlagsKHR flags; - PTR32 pVideoProfile; - VkFormat pictureFormat; - VkExtent2D maxCodedExtent; - VkFormat referencePictureFormat; - uint32_t maxDpbSlots; - uint32_t maxActiveReferencePictures; - PTR32 pStdHeaderVersion; -} VkVideoSessionCreateInfoKHR32; + uint64_t DECLSPEC_ALIGN(8) shaderCoreMask; + uint32_t shaderCoreCount; + uint32_t shaderWarpsPerCore; +} VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32;

-typedef struct StdVideoH264SequenceParameterSetVui32 +typedef struct VkPhysicalDeviceShaderCoreProperties2AMD32 { - StdVideoH264SpsVuiFlags flags; - StdVideoH264AspectRatioIdc aspect_ratio_idc; - uint16_t sar_width; - uint16_t sar_height; - uint8_t video_format; - uint8_t colour_primaries; - uint8_t transfer_characteristics; - uint8_t matrix_coefficients; - uint32_t num_units_in_tick; - uint32_t time_scale; - uint8_t max_num_reorder_frames; - uint8_t max_dec_frame_buffering; - uint8_t chroma_sample_loc_type_top_field; - uint8_t chroma_sample_loc_type_bottom_field; - uint32_t reserved1; - PTR32 pHrdParameters; -} StdVideoH264SequenceParameterSetVui32; + VkStructureType sType; + PTR32 pNext; + VkShaderCorePropertiesFlagsAMD shaderCoreFeatures; + uint32_t activeComputeUnitCount; +} VkPhysicalDeviceShaderCoreProperties2AMD32;

-typedef struct StdVideoH264SequenceParameterSet32 +typedef struct VkPhysicalDeviceShaderCorePropertiesAMD32 { - StdVideoH264SpsFlags flags; - StdVideoH264ProfileIdc profile_idc; - StdVideoH264LevelIdc level_idc; - StdVideoH264ChromaFormatIdc chroma_format_idc; - uint8_t seq_parameter_set_id; - uint8_t bit_depth_luma_minus8; - uint8_t bit_depth_chroma_minus8; - uint8_t log2_max_frame_num_minus4; - StdVideoH264PocType pic_order_cnt_type; - int32_t offset_for_non_ref_pic; - int32_t offset_for_top_to_bottom_field; - uint8_t log2_max_pic_order_cnt_lsb_minus4; - uint8_t num_ref_frames_in_pic_order_cnt_cycle; - uint8_t max_num_ref_frames; - uint8_t reserved1; - uint32_t pic_width_in_mbs_minus1; - uint32_t pic_height_in_map_units_minus1; - uint32_t frame_crop_left_offset; - uint32_t frame_crop_right_offset; - uint32_t frame_crop_top_offset; - uint32_t frame_crop_bottom_offset; - uint32_t reserved2; - PTR32 pOffsetForRefFrame; - PTR32 pScalingLists; - PTR32 pSequenceParameterSetVui; -} StdVideoH264SequenceParameterSet32; + VkStructureType sType; + PTR32 pNext; + uint32_t shaderEngineCount; + uint32_t shaderArraysPerEngineCount; + uint32_t computeUnitsPerShaderArray; + uint32_t simdPerComputeUnit; + uint32_t wavefrontsPerSimd; + uint32_t wavefrontSize; + uint32_t sgprsPerSimd; + uint32_t minSgprAllocation; + uint32_t maxSgprAllocation; + uint32_t sgprAllocationGranularity; + uint32_t vgprsPerSimd; + uint32_t minVgprAllocation; + uint32_t maxVgprAllocation; + uint32_t vgprAllocationGranularity; +} VkPhysicalDeviceShaderCorePropertiesAMD32;

-typedef struct StdVideoH264PictureParameterSet32 +typedef struct VkPhysicalDeviceShaderCorePropertiesARM32 { - StdVideoH264PpsFlags flags; - uint8_t seq_parameter_set_id; - uint8_t pic_parameter_set_id; - uint8_t num_ref_idx_l0_default_active_minus1; - uint8_t num_ref_idx_l1_default_active_minus1; - StdVideoH264WeightedBipredIdc weighted_bipred_idc; - int8_t pic_init_qp_minus26; - int8_t pic_init_qs_minus26; - int8_t chroma_qp_index_offset; - int8_t second_chroma_qp_index_offset; - PTR32 pScalingLists; -} StdVideoH264PictureParameterSet32; + VkStructureType sType; + PTR32 pNext; + uint32_t pixelRate; + uint32_t texelRate; + uint32_t fmaRate; +} VkPhysicalDeviceShaderCorePropertiesARM32;

-typedef struct VkVideoDecodeH264SessionParametersAddInfoKHR32 +typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 { VkStructureType sType; PTR32 pNext; - uint32_t stdSPSCount; - PTR32 pStdSPSs; - uint32_t stdPPSCount; - PTR32 pStdPPSs; -} VkVideoDecodeH264SessionParametersAddInfoKHR32; + VkBool32 shaderDemoteToHelperInvocation; +} VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32; +typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT32;

-typedef struct StdVideoAV1SequenceHeader32 +typedef struct VkPhysicalDeviceShaderDrawParametersFeatures32 { - StdVideoAV1SequenceHeaderFlags flags; - StdVideoAV1Profile seq_profile; - uint8_t frame_width_bits_minus_1; - uint8_t frame_height_bits_minus_1; - uint16_t max_frame_width_minus_1; - uint16_t max_frame_height_minus_1; - uint8_t delta_frame_id_length_minus_2; - uint8_t additional_frame_id_length_minus_1; - uint8_t order_hint_bits_minus_1; - uint8_t seq_force_integer_mv; - uint8_t seq_force_screen_content_tools; - uint8_t reserved1[5]; - PTR32 pColorConfig; - PTR32 pTimingInfo; -} StdVideoAV1SequenceHeader32; + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceShaderDrawParametersFeatures32; +typedef VkPhysicalDeviceShaderDrawParametersFeatures32 VkPhysicalDeviceShaderDrawParameterFeatures32;

-typedef struct VkVideoEncodeH264SessionParametersAddInfoKHR32 +typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 { VkStructureType sType; PTR32 pNext; - uint32_t stdSPSCount; - PTR32 pStdSPSs; - uint32_t stdPPSCount; - PTR32 pStdPPSs; -} VkVideoEncodeH264SessionParametersAddInfoKHR32; + VkBool32 shaderEarlyAndLateFragmentTests; +} VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32;

-typedef struct VkVideoDecodeH264SessionParametersCreateInfoKHR32 +typedef struct VkPhysicalDeviceShaderExpectAssumeFeatures32 { VkStructureType sType; PTR32 pNext; - uint32_t maxStdSPSCount; - uint32_t maxStdPPSCount; - PTR32 pParametersAddInfo; -} VkVideoDecodeH264SessionParametersCreateInfoKHR32; + VkBool32 shaderExpectAssume; +} VkPhysicalDeviceShaderExpectAssumeFeatures32; +typedef VkPhysicalDeviceShaderExpectAssumeFeatures32 VkPhysicalDeviceShaderExpectAssumeFeaturesKHR32;

-typedef struct VkVideoDecodeAV1SessionParametersCreateInfoKHR32 +typedef struct VkPhysicalDeviceShaderFloat16Int8Features32 { VkStructureType sType; PTR32 pNext; - PTR32 pStdSequenceHeader; -} VkVideoDecodeAV1SessionParametersCreateInfoKHR32; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; +} VkPhysicalDeviceShaderFloat16Int8Features32; +typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceShaderFloat16Int8FeaturesKHR32; +typedef VkPhysicalDeviceShaderFloat16Int8Features32 VkPhysicalDeviceFloat16Int8FeaturesKHR32;

-typedef struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32 +typedef struct VkPhysicalDeviceShaderFloat8FeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkExtent2D quantizationMapTexelSize; -} VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32; + VkBool32 shaderFloat8; + VkBool32 shaderFloat8CooperativeMatrix; +} VkPhysicalDeviceShaderFloat8FeaturesEXT32;

-typedef struct VkVideoEncodeH264SessionParametersCreateInfoKHR32 +typedef struct VkPhysicalDeviceShaderFloatControls2Features32 { VkStructureType sType; PTR32 pNext; - uint32_t maxStdSPSCount; - uint32_t maxStdPPSCount; - PTR32 pParametersAddInfo; -} VkVideoEncodeH264SessionParametersCreateInfoKHR32; + VkBool32 shaderFloatControls2; +} VkPhysicalDeviceShaderFloatControls2Features32; +typedef VkPhysicalDeviceShaderFloatControls2Features32 VkPhysicalDeviceShaderFloatControls2FeaturesKHR32;

-typedef struct VkVideoEncodeAV1SessionParametersCreateInfoKHR32 +typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 { VkStructureType sType; PTR32 pNext; - PTR32 pStdSequenceHeader; - PTR32 pStdDecoderModelInfo; - uint32_t stdOperatingPointCount; - PTR32 pStdOperatingPoints; -} VkVideoEncodeAV1SessionParametersCreateInfoKHR32; + VkBool32 shaderImageInt64Atomics; + VkBool32 sparseImageInt64Atomics; +} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32;

-typedef struct VkVideoSessionParametersCreateInfoKHR32 +typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkVideoSessionParametersCreateFlagsKHR flags; - VkVideoSessionParametersKHR DECLSPEC_ALIGN(8) videoSessionParametersTemplate; - VkVideoSessionKHR DECLSPEC_ALIGN(8) videoSession; -} VkVideoSessionParametersCreateInfoKHR32; + VkBool32 imageFootprint; +} VkPhysicalDeviceShaderImageFootprintFeaturesNV32;

-typedef struct VkWin32SurfaceCreateInfoKHR32 +typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures32 { VkStructureType sType; PTR32 pNext; - VkWin32SurfaceCreateFlagsKHR flags; - PTR32 hinstance; - PTR32 hwnd; -} VkWin32SurfaceCreateInfoKHR32; + VkBool32 shaderIntegerDotProduct; +} VkPhysicalDeviceShaderIntegerDotProductFeatures32; +typedef VkPhysicalDeviceShaderIntegerDotProductFeatures32 VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR32;

-typedef struct VkDebugMarkerObjectNameInfoEXT32 +typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties32 { VkStructureType sType; PTR32 pNext; - VkDebugReportObjectTypeEXT objectType; - uint64_t DECLSPEC_ALIGN(8) object; - PTR32 pObjectName; -} VkDebugMarkerObjectNameInfoEXT32; + VkBool32 integerDotProduct8BitUnsignedAccelerated; + VkBool32 integerDotProduct8BitSignedAccelerated; + VkBool32 integerDotProduct8BitMixedSignednessAccelerated; + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProduct16BitUnsignedAccelerated; + VkBool32 integerDotProduct16BitSignedAccelerated; + VkBool32 integerDotProduct16BitMixedSignednessAccelerated; + VkBool32 integerDotProduct32BitUnsignedAccelerated; + VkBool32 integerDotProduct32BitSignedAccelerated; + VkBool32 integerDotProduct32BitMixedSignednessAccelerated; + VkBool32 integerDotProduct64BitUnsignedAccelerated; + VkBool32 integerDotProduct64BitSignedAccelerated; + VkBool32 integerDotProduct64BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; +} VkPhysicalDeviceShaderIntegerDotProductProperties32; +typedef VkPhysicalDeviceShaderIntegerDotProductProperties32 VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR32;

-typedef struct VkDebugMarkerObjectTagInfoEXT32 +typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 { VkStructureType sType; PTR32 pNext; - VkDebugReportObjectTypeEXT objectType; - uint64_t DECLSPEC_ALIGN(8) object; - uint64_t DECLSPEC_ALIGN(8) tagName; - PTR32 tagSize; - PTR32 pTag; -} VkDebugMarkerObjectTagInfoEXT32; + VkBool32 shaderIntegerFunctions2; +} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32;

-typedef struct VkPhysicalDeviceGroupProperties32 +typedef struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t physicalDeviceCount; - PTR32 physicalDevices[VK_MAX_DEVICE_GROUP_SIZE]; - VkBool32 subsetAllocation; -} VkPhysicalDeviceGroupProperties32; -typedef VkPhysicalDeviceGroupProperties32 VkPhysicalDeviceGroupPropertiesKHR32; + VkBool32 shaderMaximalReconvergence; +} VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32;

-typedef struct VkPerformanceCounterKHR32 +typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkPerformanceCounterUnitKHR unit; - VkPerformanceCounterScopeKHR scope; - VkPerformanceCounterStorageKHR storage; - uint8_t uuid[VK_UUID_SIZE]; -} VkPerformanceCounterKHR32; + VkBool32 shaderModuleIdentifier; +} VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32;

-typedef struct VkPerformanceCounterDescriptionKHR32 +typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkPerformanceCounterDescriptionFlagsKHR flags; - char name[VK_MAX_DESCRIPTION_SIZE]; - char category[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; -} VkPerformanceCounterDescriptionKHR32; + uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE]; +} VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32;

-typedef struct VkMappedMemoryRange32 +typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkDeviceMemory DECLSPEC_ALIGN(8) memory; - VkDeviceSize DECLSPEC_ALIGN(8) offset; - VkDeviceSize DECLSPEC_ALIGN(8) size; -} VkMappedMemoryRange32; + VkBool32 shaderObject; +} VkPhysicalDeviceShaderObjectFeaturesEXT32;

-typedef struct VkAccelerationStructureBuildSizesInfoKHR32 +typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) accelerationStructureSize; - VkDeviceSize DECLSPEC_ALIGN(8) updateScratchSize; - VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize; -} VkAccelerationStructureBuildSizesInfoKHR32; + uint8_t shaderBinaryUUID[VK_UUID_SIZE]; + uint32_t shaderBinaryVersion; +} VkPhysicalDeviceShaderObjectPropertiesEXT32;

-typedef struct VkAccelerationStructureDeviceAddressInfoKHR32 +typedef struct VkPhysicalDeviceShaderQuadControlFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure; -} VkAccelerationStructureDeviceAddressInfoKHR32; + VkBool32 shaderQuadControl; +} VkPhysicalDeviceShaderQuadControlFeaturesKHR32;

-typedef struct VkAccelerationStructureMemoryRequirementsInfoNV32 +typedef struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkAccelerationStructureMemoryRequirementsTypeNV type; - VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructure; -} VkAccelerationStructureMemoryRequirementsInfoNV32; + VkBool32 shaderRelaxedExtendedInstruction; +} VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32;

-typedef struct VkMemoryRequirements32 +typedef struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 { - VkDeviceSize DECLSPEC_ALIGN(8) size; - VkDeviceSize DECLSPEC_ALIGN(8) alignment; - uint32_t memoryTypeBits; -} VkMemoryRequirements32; + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderReplicatedComposites; +} VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32;

+typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 shaderSMBuiltins; +} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32;

-typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT32 +typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkAccelerationStructureKHR DECLSPEC_ALIGN(8) accelerationStructure; - VkAccelerationStructureNV DECLSPEC_ALIGN(8) accelerationStructureNV; -} VkAccelerationStructureCaptureDescriptorDataInfoEXT32; + uint32_t shaderSMCount; + uint32_t shaderWarpsPerSM; +} VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32;

-typedef struct VkBufferDeviceAddressInfo32 +typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 { VkStructureType sType; PTR32 pNext; - VkBuffer DECLSPEC_ALIGN(8) buffer; -} VkBufferDeviceAddressInfo32; -typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoKHR32; -typedef VkBufferDeviceAddressInfo32 VkBufferDeviceAddressInfoEXT32; + VkBool32 shaderSubgroupExtendedTypes; +} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32; +typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR32;

-typedef struct VkBufferMemoryRequirementsInfo232 +typedef struct VkPhysicalDeviceShaderSubgroupRotateFeatures32 { VkStructureType sType; PTR32 pNext; - VkBuffer DECLSPEC_ALIGN(8) buffer; -} VkBufferMemoryRequirementsInfo232; -typedef VkBufferMemoryRequirementsInfo232 VkBufferMemoryRequirementsInfo2KHR32; + VkBool32 shaderSubgroupRotate; + VkBool32 shaderSubgroupRotateClustered; +} VkPhysicalDeviceShaderSubgroupRotateFeatures32; +typedef VkPhysicalDeviceShaderSubgroupRotateFeatures32 VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR32;

-typedef struct VkMemoryDedicatedRequirements32 +typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 prefersDedicatedAllocation; - VkBool32 requiresDedicatedAllocation; -} VkMemoryDedicatedRequirements32; -typedef VkMemoryDedicatedRequirements32 VkMemoryDedicatedRequirementsKHR32; + VkBool32 shaderSubgroupUniformControlFlow; +} VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32;

-typedef struct VkTileMemoryRequirementsQCOM32 +typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures32 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) size; - VkDeviceSize DECLSPEC_ALIGN(8) alignment; -} VkTileMemoryRequirementsQCOM32; + VkBool32 shaderTerminateInvocation; +} VkPhysicalDeviceShaderTerminateInvocationFeatures32; +typedef VkPhysicalDeviceShaderTerminateInvocationFeatures32 VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR32;

-typedef struct VkMemoryRequirements232 +typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements; -} VkMemoryRequirements232; -typedef VkMemoryRequirements232 VkMemoryRequirements2KHR32; + VkBool32 shaderTileImageColorReadAccess; + VkBool32 shaderTileImageDepthReadAccess; + VkBool32 shaderTileImageStencilReadAccess; +} VkPhysicalDeviceShaderTileImageFeaturesEXT32;

-typedef struct VkBufferCaptureDescriptorDataInfoEXT32 +typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkBuffer DECLSPEC_ALIGN(8) buffer; -} VkBufferCaptureDescriptorDataInfoEXT32; + VkBool32 shaderTileImageCoherentReadAccelerated; + VkBool32 shaderTileImageReadSampleFromPixelRateInvocation; + VkBool32 shaderTileImageReadFromHelperInvocation; +} VkPhysicalDeviceShaderTileImagePropertiesEXT32;

-typedef struct VkCalibratedTimestampInfoKHR32 +typedef struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkTimeDomainKHR timeDomain; -} VkCalibratedTimestampInfoKHR32; -typedef VkCalibratedTimestampInfoKHR32 VkCalibratedTimestampInfoEXT32; + VkBool32 shaderUntypedPointers; +} VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32;

-typedef struct VkDataGraphPipelineInfoARM32 +typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV32 { VkStructureType sType; PTR32 pNext; - VkPipeline DECLSPEC_ALIGN(8) dataGraphPipeline; -} VkDataGraphPipelineInfoARM32; + VkBool32 shadingRateImage; + VkBool32 shadingRateCoarseSampleOrder; +} VkPhysicalDeviceShadingRateImageFeaturesNV32;

-typedef struct VkDataGraphPipelinePropertyQueryResultARM32 +typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV32 { VkStructureType sType; PTR32 pNext; - VkDataGraphPipelinePropertyARM property; - VkBool32 isText; - PTR32 dataSize; - PTR32 pData; -} VkDataGraphPipelinePropertyQueryResultARM32; + VkExtent2D shadingRateTexelSize; + uint32_t shadingRatePaletteSize; + uint32_t shadingRateMaxCoarseSamples; +} VkPhysicalDeviceShadingRateImagePropertiesNV32;

-typedef struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM32 +typedef struct VkPhysicalDeviceSparseImageFormatInfo232 { VkStructureType sType; PTR32 pNext; - VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session; -} VkDataGraphPipelineSessionBindPointRequirementsInfoARM32; + VkFormat format; + VkImageType type; + VkSampleCountFlagBits samples; + VkImageUsageFlags usage; + VkImageTiling tiling; +} VkPhysicalDeviceSparseImageFormatInfo232; +typedef VkPhysicalDeviceSparseImageFormatInfo232 VkPhysicalDeviceSparseImageFormatInfo2KHR32;

-typedef struct VkDataGraphPipelineSessionBindPointRequirementARM32 +typedef struct VkPhysicalDeviceSubgroupProperties32 { VkStructureType sType; PTR32 pNext; - VkDataGraphPipelineSessionBindPointARM bindPoint; - VkDataGraphPipelineSessionBindPointTypeARM bindPointType; - uint32_t numObjects; -} VkDataGraphPipelineSessionBindPointRequirementARM32; + uint32_t subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; +} VkPhysicalDeviceSubgroupProperties32;

-typedef struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM32 +typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures32 { VkStructureType sType; PTR32 pNext; - VkDataGraphPipelineSessionARM DECLSPEC_ALIGN(8) session; - VkDataGraphPipelineSessionBindPointARM bindPoint; - uint32_t objectIndex; -} VkDataGraphPipelineSessionMemoryRequirementsInfoARM32; + VkBool32 subgroupSizeControl; + VkBool32 computeFullSubgroups; +} VkPhysicalDeviceSubgroupSizeControlFeatures32; +typedef VkPhysicalDeviceSubgroupSizeControlFeatures32 VkPhysicalDeviceSubgroupSizeControlFeaturesEXT32;

-typedef struct VkDescriptorAddressInfoEXT32 +typedef struct VkPhysicalDeviceSubgroupSizeControlProperties32 { VkStructureType sType; PTR32 pNext; - VkDeviceAddress DECLSPEC_ALIGN(8) address; - VkDeviceSize DECLSPEC_ALIGN(8) range; - VkFormat format; -} VkDescriptorAddressInfoEXT32; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; +} VkPhysicalDeviceSubgroupSizeControlProperties32; +typedef VkPhysicalDeviceSubgroupSizeControlProperties32 VkPhysicalDeviceSubgroupSizeControlPropertiesEXT32;

-typedef union VkDescriptorDataEXT32 +typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 { - PTR32 pSampler; - PTR32 pCombinedImageSampler; - PTR32 pInputAttachmentImage; - PTR32 pSampledImage; - PTR32 pStorageImage; - PTR32 pUniformTexelBuffer; - PTR32 pStorageTexelBuffer; - PTR32 pUniformBuffer; - PTR32 pStorageBuffer; - VkDeviceAddress DECLSPEC_ALIGN(8) accelerationStructure; -} VkDescriptorDataEXT32; + VkStructureType sType; + PTR32 pNext; + VkBool32 subpassMergeFeedback; +} VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32;

-typedef struct VkDescriptorGetTensorInfoARM32 +typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 { VkStructureType sType; PTR32 pNext; - VkTensorViewARM DECLSPEC_ALIGN(8) tensorView; -} VkDescriptorGetTensorInfoARM32; + VkBool32 subpassShading; +} VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32;

-typedef struct VkDescriptorGetInfoEXT32 +typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32 { VkStructureType sType; PTR32 pNext; - VkDescriptorType type; - VkDescriptorDataEXT32 DECLSPEC_ALIGN(8) data; -} VkDescriptorGetInfoEXT32; + uint32_t maxSubpassShadingWorkgroupSizeAspectRatio; +} VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32;

-typedef struct VkDescriptorSetBindingReferenceVALVE32 +typedef struct VkPhysicalDeviceSurfaceInfo2KHR32 { VkStructureType sType; PTR32 pNext; - VkDescriptorSetLayout DECLSPEC_ALIGN(8) descriptorSetLayout; - uint32_t binding; -} VkDescriptorSetBindingReferenceVALVE32; + VkSurfaceKHR DECLSPEC_ALIGN(8) surface; +} VkPhysicalDeviceSurfaceInfo2KHR32;

-typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE32 +typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 { VkStructureType sType; PTR32 pNext; - PTR32 descriptorOffset; - uint32_t descriptorSize; -} VkDescriptorSetLayoutHostMappingInfoVALVE32; + VkBool32 swapchainMaintenance1; +} VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32; +typedef VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT32;

-typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport32 +typedef struct VkPhysicalDeviceSynchronization2Features32 { VkStructureType sType; PTR32 pNext; - uint32_t maxVariableDescriptorCount; -} VkDescriptorSetVariableDescriptorCountLayoutSupport32; -typedef VkDescriptorSetVariableDescriptorCountLayoutSupport32 VkDescriptorSetVariableDescriptorCountLayoutSupportEXT32; + VkBool32 synchronization2; +} VkPhysicalDeviceSynchronization2Features32; +typedef VkPhysicalDeviceSynchronization2Features32 VkPhysicalDeviceSynchronization2FeaturesKHR32;

-typedef struct VkDescriptorSetLayoutSupport32 +typedef struct VkPhysicalDeviceTensorFeaturesARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 supported; -} VkDescriptorSetLayoutSupport32; -typedef VkDescriptorSetLayoutSupport32 VkDescriptorSetLayoutSupportKHR32; + VkBool32 tensorNonPacked; + VkBool32 shaderTensorAccess; + VkBool32 shaderStorageTensorArrayDynamicIndexing; + VkBool32 shaderStorageTensorArrayNonUniformIndexing; + VkBool32 descriptorBindingStorageTensorUpdateAfterBind; + VkBool32 tensors; +} VkPhysicalDeviceTensorFeaturesARM32;

-typedef struct VkAccelerationStructureVersionInfoKHR32 +typedef struct VkPhysicalDeviceTensorPropertiesARM32 { VkStructureType sType; PTR32 pNext; - PTR32 pVersionData; -} VkAccelerationStructureVersionInfoKHR32; + uint32_t maxTensorDimensionCount; + uint64_t DECLSPEC_ALIGN(8) maxTensorElements; + uint64_t DECLSPEC_ALIGN(8) maxPerDimensionTensorElements; + int64_t maxTensorStride; + uint64_t DECLSPEC_ALIGN(8) maxTensorSize; + uint32_t maxTensorShaderAccessArrayLength; + uint32_t maxTensorShaderAccessSize; + uint32_t maxDescriptorSetStorageTensors; + uint32_t maxPerStageDescriptorSetStorageTensors; + uint32_t maxDescriptorSetUpdateAfterBindStorageTensors; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors; + VkBool32 shaderStorageTensorArrayNonUniformIndexingNative; + VkShaderStageFlags shaderTensorSupportedStages; +} VkPhysicalDeviceTensorPropertiesARM32;

-typedef struct VkDeviceBufferMemoryRequirements32 +typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - PTR32 pCreateInfo; -} VkDeviceBufferMemoryRequirements32; -typedef VkDeviceBufferMemoryRequirements32 VkDeviceBufferMemoryRequirementsKHR32; + VkBool32 texelBufferAlignment; +} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32;

-typedef struct VkDeviceFaultCountsEXT32 +typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties32 { VkStructureType sType; PTR32 pNext; - uint32_t addressInfoCount; - uint32_t vendorInfoCount; - VkDeviceSize DECLSPEC_ALIGN(8) vendorBinarySize; -} VkDeviceFaultCountsEXT32; + VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; +} VkPhysicalDeviceTexelBufferAlignmentProperties32; +typedef VkPhysicalDeviceTexelBufferAlignmentProperties32 VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT32;

-typedef struct VkDeviceFaultAddressInfoEXT32 +typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 { - VkDeviceFaultAddressTypeEXT addressType; - VkDeviceAddress DECLSPEC_ALIGN(8) reportedAddress; - VkDeviceSize DECLSPEC_ALIGN(8) addressPrecision; -} VkDeviceFaultAddressInfoEXT32; + VkStructureType sType; + PTR32 pNext; + VkBool32 textureCompressionASTC_HDR; +} VkPhysicalDeviceTextureCompressionASTCHDRFeatures32; +typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT32;

-typedef struct VkDeviceFaultVendorInfoEXT32 +typedef struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 { - char description[VK_MAX_DESCRIPTION_SIZE]; - uint64_t DECLSPEC_ALIGN(8) vendorFaultCode; - uint64_t DECLSPEC_ALIGN(8) vendorFaultData; -} VkDeviceFaultVendorInfoEXT32; + VkStructureType sType; + PTR32 pNext; + VkBool32 tileMemoryHeap; +} VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32; + +typedef struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32 +{ + VkStructureType sType; + PTR32 pNext; + VkBool32 queueSubmitBoundary; + VkBool32 tileBufferTransfers; +} VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32;

-typedef struct VkDeviceFaultInfoEXT32 +typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM32 { VkStructureType sType; PTR32 pNext; - char description[VK_MAX_DESCRIPTION_SIZE]; - PTR32 pAddressInfos; - PTR32 pVendorInfos; - PTR32 pVendorBinaryData; -} VkDeviceFaultInfoEXT32; + VkBool32 tileProperties; +} VkPhysicalDeviceTilePropertiesFeaturesQCOM32;

-typedef struct VkDeviceGroupPresentCapabilitiesKHR32 +typedef struct VkPhysicalDeviceTileShadingFeaturesQCOM32 { VkStructureType sType; PTR32 pNext; - uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE]; - VkDeviceGroupPresentModeFlagsKHR modes; -} VkDeviceGroupPresentCapabilitiesKHR32; + VkBool32 tileShading; + VkBool32 tileShadingFragmentStage; + VkBool32 tileShadingColorAttachments; + VkBool32 tileShadingDepthAttachments; + VkBool32 tileShadingStencilAttachments; + VkBool32 tileShadingInputAttachments; + VkBool32 tileShadingSampledAttachments; + VkBool32 tileShadingPerTileDraw; + VkBool32 tileShadingPerTileDispatch; + VkBool32 tileShadingDispatchTile; + VkBool32 tileShadingApron; + VkBool32 tileShadingAnisotropicApron; + VkBool32 tileShadingAtomicOps; + VkBool32 tileShadingImageProcessing; +} VkPhysicalDeviceTileShadingFeaturesQCOM32;

-typedef struct VkDeviceImageMemoryRequirements32 +typedef struct VkPhysicalDeviceTileShadingPropertiesQCOM32 { VkStructureType sType; PTR32 pNext; - PTR32 pCreateInfo; - VkImageAspectFlagBits planeAspect; -} VkDeviceImageMemoryRequirements32; -typedef VkDeviceImageMemoryRequirements32 VkDeviceImageMemoryRequirementsKHR32; + uint32_t maxApronSize; + VkBool32 preferNonCoherent; + VkExtent2D tileGranularity; + VkExtent2D maxTileShadingRate; +} VkPhysicalDeviceTileShadingPropertiesQCOM32;

-typedef struct VkSparseImageMemoryRequirements32 +typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures32 { - VkSparseImageFormatProperties formatProperties; - uint32_t imageMipTailFirstLod; - VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailSize; - VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailOffset; - VkDeviceSize DECLSPEC_ALIGN(8) imageMipTailStride; -} VkSparseImageMemoryRequirements32; + VkStructureType sType; + PTR32 pNext; + VkBool32 timelineSemaphore; +} VkPhysicalDeviceTimelineSemaphoreFeatures32; +typedef VkPhysicalDeviceTimelineSemaphoreFeatures32 VkPhysicalDeviceTimelineSemaphoreFeaturesKHR32;

-typedef struct VkSparseImageMemoryRequirements232 +typedef struct VkPhysicalDeviceTimelineSemaphoreProperties32 { VkStructureType sType; PTR32 pNext; - VkSparseImageMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements; -} VkSparseImageMemoryRequirements232; -typedef VkSparseImageMemoryRequirements232 VkSparseImageMemoryRequirements2KHR32; + uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference; +} VkPhysicalDeviceTimelineSemaphoreProperties32; +typedef VkPhysicalDeviceTimelineSemaphoreProperties32 VkPhysicalDeviceTimelineSemaphorePropertiesKHR32;

-typedef struct VkImageSubresource232 +typedef struct VkPhysicalDeviceToolProperties32 { VkStructureType sType; PTR32 pNext; - VkImageSubresource imageSubresource; -} VkImageSubresource232; -typedef VkImageSubresource232 VkImageSubresource2KHR32; -typedef VkImageSubresource232 VkImageSubresource2EXT32; + char name[VK_MAX_EXTENSION_NAME_SIZE]; + char version[VK_MAX_EXTENSION_NAME_SIZE]; + VkToolPurposeFlags purposes; + char description[VK_MAX_DESCRIPTION_SIZE]; + char layer[VK_MAX_EXTENSION_NAME_SIZE]; +} VkPhysicalDeviceToolProperties32; +typedef VkPhysicalDeviceToolProperties32 VkPhysicalDeviceToolPropertiesEXT32;

-typedef struct VkDeviceImageSubresourceInfo32 +typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - PTR32 pCreateInfo; - PTR32 pSubresource; -} VkDeviceImageSubresourceInfo32; -typedef VkDeviceImageSubresourceInfo32 VkDeviceImageSubresourceInfoKHR32; + VkBool32 transformFeedback; + VkBool32 geometryStreams; +} VkPhysicalDeviceTransformFeedbackFeaturesEXT32;

-typedef struct VkSubresourceLayout32 +typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT32 { - VkDeviceSize DECLSPEC_ALIGN(8) offset; - VkDeviceSize DECLSPEC_ALIGN(8) size; - VkDeviceSize DECLSPEC_ALIGN(8) rowPitch; - VkDeviceSize DECLSPEC_ALIGN(8) arrayPitch; - VkDeviceSize DECLSPEC_ALIGN(8) depthPitch; -} VkSubresourceLayout32; + VkStructureType sType; + PTR32 pNext; + uint32_t maxTransformFeedbackStreams; + uint32_t maxTransformFeedbackBuffers; + VkDeviceSize DECLSPEC_ALIGN(8) maxTransformFeedbackBufferSize; + uint32_t maxTransformFeedbackStreamDataSize; + uint32_t maxTransformFeedbackBufferDataSize; + uint32_t maxTransformFeedbackBufferDataStride; + VkBool32 transformFeedbackQueries; + VkBool32 transformFeedbackStreamsLinesTriangles; + VkBool32 transformFeedbackRasterizationStreamSelect; + VkBool32 transformFeedbackDraw; +} VkPhysicalDeviceTransformFeedbackPropertiesEXT32;

-typedef struct VkSubresourceHostMemcpySize32 +typedef struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) size; -} VkSubresourceHostMemcpySize32; -typedef VkSubresourceHostMemcpySize32 VkSubresourceHostMemcpySizeEXT32; + VkBool32 unifiedImageLayouts; + VkBool32 unifiedImageLayoutsVideo; +} VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32;

-typedef struct VkImageCompressionPropertiesEXT32 +typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 { VkStructureType sType; PTR32 pNext; - VkImageCompressionFlagsEXT imageCompressionFlags; - VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags; -} VkImageCompressionPropertiesEXT32; + VkBool32 uniformBufferStandardLayout; +} VkPhysicalDeviceUniformBufferStandardLayoutFeatures32; +typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR32;

-typedef struct VkSubresourceLayout232 +typedef struct VkPhysicalDeviceVariablePointersFeatures32 { VkStructureType sType; PTR32 pNext; - VkSubresourceLayout32 DECLSPEC_ALIGN(8) subresourceLayout; -} VkSubresourceLayout232; -typedef VkSubresourceLayout232 VkSubresourceLayout2KHR32; -typedef VkSubresourceLayout232 VkSubresourceLayout2EXT32; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointersFeatures32; +typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointersFeaturesKHR32; +typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeaturesKHR32; +typedef VkPhysicalDeviceVariablePointersFeatures32 VkPhysicalDeviceVariablePointerFeatures32;

-typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo32 +typedef struct VkPhysicalDeviceVertexAttributeDivisorFeatures32 { VkStructureType sType; PTR32 pNext; - VkDeviceMemory DECLSPEC_ALIGN(8) memory; -} VkDeviceMemoryOpaqueCaptureAddressInfo32; -typedef VkDeviceMemoryOpaqueCaptureAddressInfo32 VkDeviceMemoryOpaqueCaptureAddressInfoKHR32; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; +} VkPhysicalDeviceVertexAttributeDivisorFeatures32; +typedef VkPhysicalDeviceVertexAttributeDivisorFeatures32 VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR32; +typedef VkPhysicalDeviceVertexAttributeDivisorFeatures32 VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT32;

-typedef struct VkMicromapVersionInfoEXT32 +typedef struct VkPhysicalDeviceVertexAttributeDivisorProperties32 { VkStructureType sType; PTR32 pNext; - PTR32 pVersionData; -} VkMicromapVersionInfoEXT32; + uint32_t maxVertexAttribDivisor; + VkBool32 supportsNonZeroFirstInstance; +} VkPhysicalDeviceVertexAttributeDivisorProperties32; +typedef VkPhysicalDeviceVertexAttributeDivisorProperties32 VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR32;

-typedef struct VkDeviceQueueInfo232 +typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32 { VkStructureType sType; PTR32 pNext; - VkDeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueIndex; -} VkDeviceQueueInfo232; + uint32_t maxVertexAttribDivisor; +} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32;

-typedef struct VkDeviceTensorMemoryRequirementsARM32 +typedef struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - PTR32 pCreateInfo; -} VkDeviceTensorMemoryRequirementsARM32; + VkBool32 vertexAttributeRobustness; +} VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32;

-typedef struct VkTilePropertiesQCOM32 +typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkExtent3D tileSize; - VkExtent2D apronSize; - VkOffset2D origin; -} VkTilePropertiesQCOM32; + VkBool32 vertexInputDynamicState; +} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32;

-typedef struct VkVideoEncodeH264SessionParametersGetInfoKHR32 +typedef struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 writeStdSPS; - VkBool32 writeStdPPS; - uint32_t stdSPSId; - uint32_t stdPPSId; -} VkVideoEncodeH264SessionParametersGetInfoKHR32; + VkBool32 videoDecodeVP9; +} VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32;

-typedef struct VkVideoEncodeSessionParametersGetInfoKHR32 +typedef struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoSessionParametersKHR DECLSPEC_ALIGN(8) videoSessionParameters; -} VkVideoEncodeSessionParametersGetInfoKHR32; + VkBool32 videoEncodeAV1; +} VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32;

-typedef struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR32 +typedef struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 hasStdSPSOverrides; - VkBool32 hasStdPPSOverrides; -} VkVideoEncodeH264SessionParametersFeedbackInfoKHR32; + VkBool32 videoEncodeIntraRefresh; +} VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32;

-typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR32 +typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 hasOverrides; -} VkVideoEncodeSessionParametersFeedbackInfoKHR32; + PTR32 pVideoProfile; + uint32_t qualityLevel; +} VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR32;

-typedef struct VkGeneratedCommandsMemoryRequirementsInfoEXT32 +typedef struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkIndirectExecutionSetEXT DECLSPEC_ALIGN(8) indirectExecutionSet; - VkIndirectCommandsLayoutEXT DECLSPEC_ALIGN(8) indirectCommandsLayout; - uint32_t maxSequenceCount; - uint32_t maxDrawCount; -} VkGeneratedCommandsMemoryRequirementsInfoEXT32; + VkBool32 videoEncodeQuantizationMap; +} VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32;

-typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV32 +typedef struct VkPhysicalDeviceVideoFormatInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkPipelineBindPoint pipelineBindPoint; - VkPipeline DECLSPEC_ALIGN(8) pipeline; - VkIndirectCommandsLayoutNV DECLSPEC_ALIGN(8) indirectCommandsLayout; - uint32_t maxSequencesCount; -} VkGeneratedCommandsMemoryRequirementsInfoNV32; + VkImageUsageFlags imageUsage; +} VkPhysicalDeviceVideoFormatInfoKHR32;

-typedef struct VkImagePlaneMemoryRequirementsInfo32 +typedef struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkImageAspectFlagBits planeAspect; -} VkImagePlaneMemoryRequirementsInfo32; -typedef VkImagePlaneMemoryRequirementsInfo32 VkImagePlaneMemoryRequirementsInfoKHR32; + VkBool32 videoMaintenance1; +} VkPhysicalDeviceVideoMaintenance1FeaturesKHR32;

-typedef struct VkImageMemoryRequirementsInfo232 +typedef struct VkPhysicalDeviceVulkan11Features32 { VkStructureType sType; PTR32 pNext; - VkImage DECLSPEC_ALIGN(8) image; -} VkImageMemoryRequirementsInfo232; -typedef VkImageMemoryRequirementsInfo232 VkImageMemoryRequirementsInfo2KHR32; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; + VkBool32 protectedMemory; + VkBool32 samplerYcbcrConversion; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceVulkan11Features32;

-typedef struct VkImageCaptureDescriptorDataInfoEXT32 +typedef struct VkPhysicalDeviceVulkan11Properties32 { VkStructureType sType; PTR32 pNext; - VkImage DECLSPEC_ALIGN(8) image; -} VkImageCaptureDescriptorDataInfoEXT32; + uint8_t deviceUUID[VK_UUID_SIZE]; + uint8_t driverUUID[VK_UUID_SIZE]; + uint8_t deviceLUID[VK_LUID_SIZE]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; + uint32_t subgroupSize; + VkShaderStageFlags subgroupSupportedStages; + VkSubgroupFeatureFlags subgroupSupportedOperations; + VkBool32 subgroupQuadOperationsInAllStages; + VkPointClippingBehavior pointClippingBehavior; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; + VkBool32 protectedNoFault; + uint32_t maxPerSetDescriptors; + VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize; +} VkPhysicalDeviceVulkan11Properties32;

-typedef struct VkImageSparseMemoryRequirementsInfo232 +typedef struct VkPhysicalDeviceVulkan12Features32 { VkStructureType sType; PTR32 pNext; - VkImage DECLSPEC_ALIGN(8) image; -} VkImageSparseMemoryRequirementsInfo232; -typedef VkImageSparseMemoryRequirementsInfo232 VkImageSparseMemoryRequirementsInfo2KHR32; + VkBool32 samplerMirrorClampToEdge; + VkBool32 drawIndirectCount; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; + VkBool32 descriptorIndexing; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; + VkBool32 samplerFilterMinmax; + VkBool32 scalarBlockLayout; + VkBool32 imagelessFramebuffer; + VkBool32 uniformBufferStandardLayout; + VkBool32 shaderSubgroupExtendedTypes; + VkBool32 separateDepthStencilLayouts; + VkBool32 hostQueryReset; + VkBool32 timelineSemaphore; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; + VkBool32 shaderOutputViewportIndex; + VkBool32 shaderOutputLayer; + VkBool32 subgroupBroadcastDynamicId; +} VkPhysicalDeviceVulkan12Features32;

-typedef struct VkImageViewAddressPropertiesNVX32 +typedef struct VkPhysicalDeviceVulkan12Properties32 { VkStructureType sType; PTR32 pNext; - VkDeviceAddress DECLSPEC_ALIGN(8) deviceAddress; - VkDeviceSize DECLSPEC_ALIGN(8) size; -} VkImageViewAddressPropertiesNVX32; + VkDriverId driverID; + char driverName[VK_MAX_DRIVER_NAME_SIZE]; + char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; + VkConformanceVersion conformanceVersion; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; + uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference; + VkSampleCountFlags framebufferIntegerColorSampleCounts; +} VkPhysicalDeviceVulkan12Properties32;

-typedef struct VkImageViewHandleInfoNVX32 +typedef struct VkPhysicalDeviceVulkan13Features32 { VkStructureType sType; PTR32 pNext; - VkImageView DECLSPEC_ALIGN(8) imageView; - VkDescriptorType descriptorType; - VkSampler DECLSPEC_ALIGN(8) sampler; -} VkImageViewHandleInfoNVX32; + VkBool32 robustImageAccess; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; + VkBool32 pipelineCreationCacheControl; + VkBool32 privateData; + VkBool32 shaderDemoteToHelperInvocation; + VkBool32 shaderTerminateInvocation; + VkBool32 subgroupSizeControl; + VkBool32 computeFullSubgroups; + VkBool32 synchronization2; + VkBool32 textureCompressionASTC_HDR; + VkBool32 shaderZeroInitializeWorkgroupMemory; + VkBool32 dynamicRendering; + VkBool32 shaderIntegerDotProduct; + VkBool32 maintenance4; +} VkPhysicalDeviceVulkan13Features32;

-typedef struct VkImageViewCaptureDescriptorDataInfoEXT32 +typedef struct VkPhysicalDeviceVulkan13Properties32 { VkStructureType sType; PTR32 pNext; - VkImageView DECLSPEC_ALIGN(8) imageView; -} VkImageViewCaptureDescriptorDataInfoEXT32; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + uint32_t maxInlineUniformTotalSize; + VkBool32 integerDotProduct8BitUnsignedAccelerated; + VkBool32 integerDotProduct8BitSignedAccelerated; + VkBool32 integerDotProduct8BitMixedSignednessAccelerated; + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProduct16BitUnsignedAccelerated; + VkBool32 integerDotProduct16BitSignedAccelerated; + VkBool32 integerDotProduct16BitMixedSignednessAccelerated; + VkBool32 integerDotProduct32BitUnsignedAccelerated; + VkBool32 integerDotProduct32BitSignedAccelerated; + VkBool32 integerDotProduct32BitMixedSignednessAccelerated; + VkBool32 integerDotProduct64BitUnsignedAccelerated; + VkBool32 integerDotProduct64BitSignedAccelerated; + VkBool32 integerDotProduct64BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize; +} VkPhysicalDeviceVulkan13Properties32;

-typedef struct VkLatencyTimingsFrameReportNV32 +typedef struct VkPhysicalDeviceVulkan14Features32 { VkStructureType sType; PTR32 pNext; - uint64_t DECLSPEC_ALIGN(8) presentID; - uint64_t DECLSPEC_ALIGN(8) inputSampleTimeUs; - uint64_t DECLSPEC_ALIGN(8) simStartTimeUs; - uint64_t DECLSPEC_ALIGN(8) simEndTimeUs; - uint64_t DECLSPEC_ALIGN(8) renderSubmitStartTimeUs; - uint64_t DECLSPEC_ALIGN(8) renderSubmitEndTimeUs; - uint64_t DECLSPEC_ALIGN(8) presentStartTimeUs; - uint64_t DECLSPEC_ALIGN(8) presentEndTimeUs; - uint64_t DECLSPEC_ALIGN(8) driverStartTimeUs; - uint64_t DECLSPEC_ALIGN(8) driverEndTimeUs; - uint64_t DECLSPEC_ALIGN(8) osRenderQueueStartTimeUs; - uint64_t DECLSPEC_ALIGN(8) osRenderQueueEndTimeUs; - uint64_t DECLSPEC_ALIGN(8) gpuRenderStartTimeUs; - uint64_t DECLSPEC_ALIGN(8) gpuRenderEndTimeUs; -} VkLatencyTimingsFrameReportNV32; + VkBool32 globalPriorityQuery; + VkBool32 shaderSubgroupRotate; + VkBool32 shaderSubgroupRotateClustered; + VkBool32 shaderFloatControls2; + VkBool32 shaderExpectAssume; + VkBool32 rectangularLines; + VkBool32 bresenhamLines; + VkBool32 smoothLines; + VkBool32 stippledRectangularLines; + VkBool32 stippledBresenhamLines; + VkBool32 stippledSmoothLines; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; + VkBool32 indexTypeUint8; + VkBool32 dynamicRenderingLocalRead; + VkBool32 maintenance5; + VkBool32 maintenance6; + VkBool32 pipelineProtectedAccess; + VkBool32 pipelineRobustness; + VkBool32 hostImageCopy; + VkBool32 pushDescriptor; +} VkPhysicalDeviceVulkan14Features32;

-typedef struct VkGetLatencyMarkerInfoNV32 +typedef struct VkPhysicalDeviceVulkan14Properties32 { VkStructureType sType; PTR32 pNext; - uint32_t timingCount; - PTR32 pTimings; -} VkGetLatencyMarkerInfoNV32; + uint32_t lineSubPixelPrecisionBits; + uint32_t maxVertexAttribDivisor; + VkBool32 supportsNonZeroFirstInstance; + uint32_t maxPushDescriptors; + VkBool32 dynamicRenderingLocalReadDepthStencilAttachments; + VkBool32 dynamicRenderingLocalReadMultisampledAttachments; + VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; + VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; + VkBool32 depthStencilSwizzleOneSupport; + VkBool32 polygonModePointSize; + VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; + VkBool32 nonStrictWideLinesUseParallelogram; + VkBool32 blockTexelViewCompatibleMultipleLayers; + uint32_t maxCombinedImageSamplerDescriptorCount; + VkBool32 fragmentShadingRateClampCombinerInputs; + VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers; + VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers; + VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs; + VkPipelineRobustnessImageBehavior defaultRobustnessImages; + uint32_t copySrcLayoutCount; + PTR32 pCopySrcLayouts; + uint32_t copyDstLayoutCount; + PTR32 pCopyDstLayouts; + uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; + VkBool32 identicalMemoryTypeRequirements; +} VkPhysicalDeviceVulkan14Properties32;

-typedef struct VkMemoryHostPointerPropertiesEXT32 +typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures32 { VkStructureType sType; PTR32 pNext; - uint32_t memoryTypeBits; -} VkMemoryHostPointerPropertiesEXT32; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; +} VkPhysicalDeviceVulkanMemoryModelFeatures32; +typedef VkPhysicalDeviceVulkanMemoryModelFeatures32 VkPhysicalDeviceVulkanMemoryModelFeaturesKHR32;

-typedef struct VkMicromapBuildSizesInfoEXT32 +typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) micromapSize; - VkDeviceSize DECLSPEC_ALIGN(8) buildScratchSize; - VkBool32 discardable; -} VkMicromapBuildSizesInfoEXT32; - -typedef union VkPerformanceValueDataINTEL32 -{ - uint32_t value32; - uint64_t DECLSPEC_ALIGN(8) value64; - float valueFloat; - VkBool32 valueBool; - PTR32 valueString; -} VkPerformanceValueDataINTEL32; - -typedef struct VkPerformanceValueINTEL32 -{ - VkPerformanceValueTypeINTEL type; - VkPerformanceValueDataINTEL32 DECLSPEC_ALIGN(8) data; -} VkPerformanceValueINTEL32; + VkBool32 workgroupMemoryExplicitLayout; + VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout; + VkBool32 workgroupMemoryExplicitLayout8BitAccess; + VkBool32 workgroupMemoryExplicitLayout16BitAccess; +} VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32;

-typedef struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 +typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t MGranularity; - uint32_t NGranularity; - uint32_t KGranularity; - VkComponentTypeKHR AType; - VkComponentTypeKHR BType; - VkComponentTypeKHR CType; - VkComponentTypeKHR ResultType; - VkBool32 saturatingAccumulation; - VkScopeKHR scope; - uint32_t workgroupInvocations; -} VkCooperativeMatrixFlexibleDimensionsPropertiesNV32; + VkBool32 ycbcr2plane444Formats; +} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32;

-typedef struct VkCooperativeMatrixPropertiesKHR32 +typedef struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 { VkStructureType sType; PTR32 pNext; - uint32_t MSize; - uint32_t NSize; - uint32_t KSize; - VkComponentTypeKHR AType; - VkComponentTypeKHR BType; - VkComponentTypeKHR CType; - VkComponentTypeKHR ResultType; - VkBool32 saturatingAccumulation; - VkScopeKHR scope; -} VkCooperativeMatrixPropertiesKHR32; + VkBool32 ycbcrDegamma; +} VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32;

-typedef struct VkCooperativeMatrixPropertiesNV32 +typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t MSize; - uint32_t NSize; - uint32_t KSize; - VkComponentTypeNV AType; - VkComponentTypeNV BType; - VkComponentTypeNV CType; - VkComponentTypeNV DType; - VkScopeNV scope; -} VkCooperativeMatrixPropertiesNV32; + VkBool32 ycbcrImageArrays; +} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32;

-typedef struct VkCooperativeVectorPropertiesNV32 +typedef struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkComponentTypeKHR inputType; - VkComponentTypeKHR inputInterpretation; - VkComponentTypeKHR matrixInterpretation; - VkComponentTypeKHR biasInterpretation; - VkComponentTypeKHR resultType; - VkBool32 transpose; -} VkCooperativeVectorPropertiesNV32; + VkBool32 zeroInitializeDeviceMemory; +} VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32;

-typedef struct VkPhysicalDeviceExternalBufferInfo32 +typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 { VkStructureType sType; PTR32 pNext; - VkBufferCreateFlags flags; - VkBufferUsageFlags usage; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalBufferInfo32; -typedef VkPhysicalDeviceExternalBufferInfo32 VkPhysicalDeviceExternalBufferInfoKHR32; + VkBool32 shaderZeroInitializeWorkgroupMemory; +} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32; +typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR32;

-typedef struct VkExternalBufferProperties32 +typedef struct VkPipelineBinaryCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkExternalMemoryProperties externalMemoryProperties; -} VkExternalBufferProperties32; -typedef VkExternalBufferProperties32 VkExternalBufferPropertiesKHR32; + PTR32 pKeysAndDataInfo; + VkPipeline DECLSPEC_ALIGN(8) pipeline; + PTR32 pPipelineCreateInfo; +} VkPipelineBinaryCreateInfoKHR32;

-typedef struct VkPhysicalDeviceExternalFenceInfo32 +typedef struct VkPipelineBinaryDataInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkExternalFenceHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalFenceInfo32; -typedef VkPhysicalDeviceExternalFenceInfo32 VkPhysicalDeviceExternalFenceInfoKHR32; + VkPipelineBinaryKHR DECLSPEC_ALIGN(8) pipelineBinary; +} VkPipelineBinaryDataInfoKHR32;

-typedef struct VkExternalFenceProperties32 +typedef struct VkPipelineBinaryHandlesInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; - VkExternalFenceHandleTypeFlags compatibleHandleTypes; - VkExternalFenceFeatureFlags externalFenceFeatures; -} VkExternalFenceProperties32; -typedef VkExternalFenceProperties32 VkExternalFencePropertiesKHR32; + uint32_t pipelineBinaryCount; + PTR32 pPipelineBinaries; +} VkPipelineBinaryHandlesInfoKHR32;

-typedef struct VkPhysicalDeviceExternalSemaphoreInfo32 +typedef struct VkPipelineBinaryInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkExternalSemaphoreHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalSemaphoreInfo32; -typedef VkPhysicalDeviceExternalSemaphoreInfo32 VkPhysicalDeviceExternalSemaphoreInfoKHR32; + uint32_t binaryCount; + PTR32 pPipelineBinaries; +} VkPipelineBinaryInfoKHR32;

-typedef struct VkExternalSemaphoreProperties32 +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; - VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; - VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; -} VkExternalSemaphoreProperties32; -typedef VkExternalSemaphoreProperties32 VkExternalSemaphorePropertiesKHR32; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; +} VkPipelineColorBlendAdvancedStateCreateInfoEXT32;

-typedef struct VkPhysicalDeviceExternalTensorInfoARM32 +typedef struct VkPipelineColorWriteCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkTensorCreateFlagsARM DECLSPEC_ALIGN(8) flags; - PTR32 pDescription; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalTensorInfoARM32; + uint32_t attachmentCount; + PTR32 pColorWriteEnables; +} VkPipelineColorWriteCreateInfoEXT32;

-typedef struct VkExternalTensorPropertiesARM32 +typedef struct VkPipelineCompilerControlCreateInfoAMD32 { VkStructureType sType; PTR32 pNext; - VkExternalMemoryProperties externalMemoryProperties; -} VkExternalTensorPropertiesARM32; + VkPipelineCompilerControlFlagsAMD compilerControlFlags; +} VkPipelineCompilerControlCreateInfoAMD32;

-typedef struct VkSubpassResolvePerformanceQueryEXT32 +typedef struct VkPipelineCoverageModulationStateCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 optimal; -} VkSubpassResolvePerformanceQueryEXT32; + VkPipelineCoverageModulationStateCreateFlagsNV flags; + VkCoverageModulationModeNV coverageModulationMode; + VkBool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + PTR32 pCoverageModulationTable; +} VkPipelineCoverageModulationStateCreateInfoNV32;

-typedef struct VkFormatProperties332 +typedef struct VkPipelineCoverageReductionStateCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingFeatures; - VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingFeatures; - VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) bufferFeatures; -} VkFormatProperties332; -typedef VkFormatProperties332 VkFormatProperties3KHR32; + VkPipelineCoverageReductionStateCreateFlagsNV flags; + VkCoverageReductionModeNV coverageReductionMode; +} VkPipelineCoverageReductionStateCreateInfoNV32;

-typedef struct VkTensorFormatPropertiesARM32 +typedef struct VkPipelineCoverageToColorStateCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingTensorFeatures; - VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingTensorFeatures; -} VkTensorFormatPropertiesARM32; + VkPipelineCoverageToColorStateCreateFlagsNV flags; + VkBool32 coverageToColorEnable; + uint32_t coverageToColorLocation; +} VkPipelineCoverageToColorStateCreateInfoNV32;

-typedef struct VkFormatProperties232 +typedef struct VkPipelineCreateFlags2CreateInfo32 { VkStructureType sType; PTR32 pNext; - VkFormatProperties formatProperties; -} VkFormatProperties232; -typedef VkFormatProperties232 VkFormatProperties2KHR32; + VkPipelineCreateFlags2 DECLSPEC_ALIGN(8) flags; +} VkPipelineCreateFlags2CreateInfo32; +typedef VkPipelineCreateFlags2CreateInfo32 VkPipelineCreateFlags2CreateInfoKHR32;

-typedef struct VkPhysicalDeviceFragmentShadingRateKHR32 +typedef struct VkPipelineCreationFeedbackCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkSampleCountFlags sampleCounts; - VkExtent2D fragmentSize; -} VkPhysicalDeviceFragmentShadingRateKHR32; - -typedef struct VkImageFormatProperties32 -{ - VkExtent3D maxExtent; - uint32_t maxMipLevels; - uint32_t maxArrayLayers; - VkSampleCountFlags sampleCounts; - VkDeviceSize DECLSPEC_ALIGN(8) maxResourceSize; -} VkImageFormatProperties32; + PTR32 pPipelineCreationFeedback; + uint32_t pipelineStageCreationFeedbackCount; + PTR32 pPipelineStageCreationFeedbacks; +} VkPipelineCreationFeedbackCreateInfo32; +typedef VkPipelineCreationFeedbackCreateInfo32 VkPipelineCreationFeedbackCreateInfoEXT32;

-typedef struct VkPhysicalDeviceExternalImageFormatInfo32 +typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalImageFormatInfo32; -typedef VkPhysicalDeviceExternalImageFormatInfo32 VkPhysicalDeviceExternalImageFormatInfoKHR32; + VkPipelineDiscardRectangleStateCreateFlagsEXT flags; + VkDiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + PTR32 pDiscardRectangles; +} VkPipelineDiscardRectangleStateCreateInfoEXT32;

-typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT32 +typedef struct VkPipelineExecutableInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkImageViewType imageViewType; -} VkPhysicalDeviceImageViewImageFormatInfoEXT32; + VkPipeline DECLSPEC_ALIGN(8) pipeline; + uint32_t executableIndex; +} VkPipelineExecutableInfoKHR32;

-typedef struct VkPhysicalDeviceImageFormatInfo232 +typedef struct VkPipelineExecutableInternalRepresentationKHR32 { VkStructureType sType; PTR32 pNext; - VkFormat format; - VkImageType type; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkImageCreateFlags flags; -} VkPhysicalDeviceImageFormatInfo232; -typedef VkPhysicalDeviceImageFormatInfo232 VkPhysicalDeviceImageFormatInfo2KHR32; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkBool32 isText; + PTR32 dataSize; + PTR32 pData; +} VkPipelineExecutableInternalRepresentationKHR32;

-typedef struct VkExternalImageFormatProperties32 +typedef struct VkPipelineExecutablePropertiesKHR32 { VkStructureType sType; PTR32 pNext; - VkExternalMemoryProperties externalMemoryProperties; -} VkExternalImageFormatProperties32; -typedef VkExternalImageFormatProperties32 VkExternalImageFormatPropertiesKHR32; + VkShaderStageFlags stages; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + uint32_t subgroupSize; +} VkPipelineExecutablePropertiesKHR32;

-typedef struct VkSamplerYcbcrConversionImageFormatProperties32 +typedef struct VkPipelineExecutableStatisticKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t combinedImageSamplerDescriptorCount; -} VkSamplerYcbcrConversionImageFormatProperties32; -typedef VkSamplerYcbcrConversionImageFormatProperties32 VkSamplerYcbcrConversionImageFormatPropertiesKHR32; + char name[VK_MAX_DESCRIPTION_SIZE]; + char description[VK_MAX_DESCRIPTION_SIZE]; + VkPipelineExecutableStatisticFormatKHR format; + VkPipelineExecutableStatisticValueKHR32 DECLSPEC_ALIGN(8) value; +} VkPipelineExecutableStatisticKHR32;

-typedef struct VkTextureLODGatherFormatPropertiesAMD32 +typedef struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32 { VkStructureType sType; PTR32 pNext; - VkBool32 supportsTextureGatherLODBiasAMD; -} VkTextureLODGatherFormatPropertiesAMD32; + uint32_t maxFragmentDensityMapLayers; +} VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32;

-typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT32 +typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 filterCubic; - VkBool32 filterCubicMinmax; -} VkFilterCubicImageViewImageFormatPropertiesEXT32; + VkFragmentShadingRateTypeNV shadingRateType; + VkFragmentShadingRateNV shadingRate; + VkFragmentShadingRateCombinerOpKHR combinerOps[2]; +} VkPipelineFragmentShadingRateEnumStateCreateInfoNV32;

-typedef struct VkHostImageCopyDevicePerformanceQuery32 +typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 optimalDeviceAccess; - VkBool32 identicalMemoryLayout; -} VkHostImageCopyDevicePerformanceQuery32; -typedef VkHostImageCopyDevicePerformanceQuery32 VkHostImageCopyDevicePerformanceQueryEXT32; + VkExtent2D fragmentSize; + VkFragmentShadingRateCombinerOpKHR combinerOps[2]; +} VkPipelineFragmentShadingRateStateCreateInfoKHR32;

-typedef struct VkImageFormatProperties232 +typedef struct VkPipelineIndirectDeviceAddressInfoNV32 { VkStructureType sType; PTR32 pNext; - VkImageFormatProperties32 DECLSPEC_ALIGN(8) imageFormatProperties; -} VkImageFormatProperties232; -typedef VkImageFormatProperties232 VkImageFormatProperties2KHR32; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline DECLSPEC_ALIGN(8) pipeline; +} VkPipelineIndirectDeviceAddressInfoNV32;

-typedef struct VkMemoryHeap32 -{ - VkDeviceSize DECLSPEC_ALIGN(8) size; - VkMemoryHeapFlags flags; -} VkMemoryHeap32;

-typedef struct VkPhysicalDeviceMemoryProperties32 +typedef struct VkPipelineInfoKHR32 { - uint32_t memoryTypeCount; - VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES]; - uint32_t memoryHeapCount; - VkMemoryHeap32 DECLSPEC_ALIGN(8) memoryHeaps[VK_MAX_MEMORY_HEAPS]; -} VkPhysicalDeviceMemoryProperties32; + VkStructureType sType; + PTR32 pNext; + VkPipeline DECLSPEC_ALIGN(8) pipeline; +} VkPipelineInfoKHR32; +typedef VkPipelineInfoKHR32 VkPipelineInfoEXT32;

-typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT32 +typedef struct VkPipelineLayoutCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) heapBudget[VK_MAX_MEMORY_HEAPS]; - VkDeviceSize DECLSPEC_ALIGN(8) heapUsage[VK_MAX_MEMORY_HEAPS]; -} VkPhysicalDeviceMemoryBudgetPropertiesEXT32; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + PTR32 pSetLayouts; + uint32_t pushConstantRangeCount; + PTR32 pPushConstantRanges; +} VkPipelineLayoutCreateInfo32;

-typedef struct VkPhysicalDeviceMemoryProperties232 +typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkPhysicalDeviceMemoryProperties32 DECLSPEC_ALIGN(8) memoryProperties; -} VkPhysicalDeviceMemoryProperties232; -typedef VkPhysicalDeviceMemoryProperties232 VkPhysicalDeviceMemoryProperties2KHR32; + VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; + VkConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; +} VkPipelineRasterizationConservativeStateCreateInfoEXT32;

-typedef struct VkMultisamplePropertiesEXT32 +typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkExtent2D maxSampleLocationGridSize; -} VkMultisamplePropertiesEXT32; + VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; + VkBool32 depthClipEnable; +} VkPipelineRasterizationDepthClipStateCreateInfoEXT32;

-typedef struct VkOpticalFlowImageFormatPropertiesNV32 +typedef struct VkPipelineRasterizationLineStateCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkFormat format; -} VkOpticalFlowImageFormatPropertiesNV32; + VkLineRasterizationMode lineRasterizationMode; + VkBool32 stippledLineEnable; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; +} VkPipelineRasterizationLineStateCreateInfo32; +typedef VkPipelineRasterizationLineStateCreateInfo32 VkPipelineRasterizationLineStateCreateInfoKHR32; +typedef VkPipelineRasterizationLineStateCreateInfo32 VkPipelineRasterizationLineStateCreateInfoEXT32;

-typedef struct VkPhysicalDeviceLimits32 +typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 { - uint32_t maxImageDimension1D; - uint32_t maxImageDimension2D; - uint32_t maxImageDimension3D; - uint32_t maxImageDimensionCube; - uint32_t maxImageArrayLayers; - uint32_t maxTexelBufferElements; - uint32_t maxUniformBufferRange; - uint32_t maxStorageBufferRange; - uint32_t maxPushConstantsSize; - uint32_t maxMemoryAllocationCount; - uint32_t maxSamplerAllocationCount; - VkDeviceSize DECLSPEC_ALIGN(8) bufferImageGranularity; - VkDeviceSize DECLSPEC_ALIGN(8) sparseAddressSpaceSize; - uint32_t maxBoundDescriptorSets; - uint32_t maxPerStageDescriptorSamplers; - uint32_t maxPerStageDescriptorUniformBuffers; - uint32_t maxPerStageDescriptorStorageBuffers; - uint32_t maxPerStageDescriptorSampledImages; - uint32_t maxPerStageDescriptorStorageImages; - uint32_t maxPerStageDescriptorInputAttachments; - uint32_t maxPerStageResources; - uint32_t maxDescriptorSetSamplers; - uint32_t maxDescriptorSetUniformBuffers; - uint32_t maxDescriptorSetUniformBuffersDynamic; - uint32_t maxDescriptorSetStorageBuffers; - uint32_t maxDescriptorSetStorageBuffersDynamic; - uint32_t maxDescriptorSetSampledImages; - uint32_t maxDescriptorSetStorageImages; - uint32_t maxDescriptorSetInputAttachments; - uint32_t maxVertexInputAttributes; - uint32_t maxVertexInputBindings; - uint32_t maxVertexInputAttributeOffset; - uint32_t maxVertexInputBindingStride; - uint32_t maxVertexOutputComponents; - uint32_t maxTessellationGenerationLevel; - uint32_t maxTessellationPatchSize; - uint32_t maxTessellationControlPerVertexInputComponents; - uint32_t maxTessellationControlPerVertexOutputComponents; - uint32_t maxTessellationControlPerPatchOutputComponents; - uint32_t maxTessellationControlTotalOutputComponents; - uint32_t maxTessellationEvaluationInputComponents; - uint32_t maxTessellationEvaluationOutputComponents; - uint32_t maxGeometryShaderInvocations; - uint32_t maxGeometryInputComponents; - uint32_t maxGeometryOutputComponents; - uint32_t maxGeometryOutputVertices; - uint32_t maxGeometryTotalOutputComponents; - uint32_t maxFragmentInputComponents; - uint32_t maxFragmentOutputAttachments; - uint32_t maxFragmentDualSrcAttachments; - uint32_t maxFragmentCombinedOutputResources; - uint32_t maxComputeSharedMemorySize; - uint32_t maxComputeWorkGroupCount[3]; - uint32_t maxComputeWorkGroupInvocations; - uint32_t maxComputeWorkGroupSize[3]; - uint32_t subPixelPrecisionBits; - uint32_t subTexelPrecisionBits; - uint32_t mipmapPrecisionBits; - uint32_t maxDrawIndexedIndexValue; - uint32_t maxDrawIndirectCount; - float maxSamplerLodBias; - float maxSamplerAnisotropy; - uint32_t maxViewports; - uint32_t maxViewportDimensions[2]; - float viewportBoundsRange[2]; - uint32_t viewportSubPixelBits; - PTR32 minMemoryMapAlignment; - VkDeviceSize DECLSPEC_ALIGN(8) minTexelBufferOffsetAlignment; - VkDeviceSize DECLSPEC_ALIGN(8) minUniformBufferOffsetAlignment; - VkDeviceSize DECLSPEC_ALIGN(8) minStorageBufferOffsetAlignment; - int32_t minTexelOffset; - uint32_t maxTexelOffset; - int32_t minTexelGatherOffset; - uint32_t maxTexelGatherOffset; - float minInterpolationOffset; - float maxInterpolationOffset; - uint32_t subPixelInterpolationOffsetBits; - uint32_t maxFramebufferWidth; - uint32_t maxFramebufferHeight; - uint32_t maxFramebufferLayers; - VkSampleCountFlags framebufferColorSampleCounts; - VkSampleCountFlags framebufferDepthSampleCounts; - VkSampleCountFlags framebufferStencilSampleCounts; - VkSampleCountFlags framebufferNoAttachmentsSampleCounts; - uint32_t maxColorAttachments; - VkSampleCountFlags sampledImageColorSampleCounts; - VkSampleCountFlags sampledImageIntegerSampleCounts; - VkSampleCountFlags sampledImageDepthSampleCounts; - VkSampleCountFlags sampledImageStencilSampleCounts; - VkSampleCountFlags storageImageSampleCounts; - uint32_t maxSampleMaskWords; - VkBool32 timestampComputeAndGraphics; - float timestampPeriod; - uint32_t maxClipDistances; - uint32_t maxCullDistances; - uint32_t maxCombinedClipAndCullDistances; - uint32_t discreteQueuePriorities; - float pointSizeRange[2]; - float lineWidthRange[2]; - float pointSizeGranularity; - float lineWidthGranularity; - VkBool32 strictLines; - VkBool32 standardSampleLocations; - VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyOffsetAlignment; - VkDeviceSize DECLSPEC_ALIGN(8) optimalBufferCopyRowPitchAlignment; - VkDeviceSize DECLSPEC_ALIGN(8) nonCoherentAtomSize; -} VkPhysicalDeviceLimits32; + VkStructureType sType; + PTR32 pNext; + VkProvokingVertexModeEXT provokingVertexMode; +} VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32;

-typedef struct VkPhysicalDeviceProperties32 +typedef struct VkPipelineRasterizationStateRasterizationOrderAMD32 { - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorID; - uint32_t deviceID; - VkPhysicalDeviceType deviceType; - char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE]; - uint8_t pipelineCacheUUID[VK_UUID_SIZE]; - VkPhysicalDeviceLimits32 DECLSPEC_ALIGN(8) limits; - VkPhysicalDeviceSparseProperties sparseProperties; -} VkPhysicalDeviceProperties32; + VkStructureType sType; + PTR32 pNext; + VkRasterizationOrderAMD rasterizationOrder; +} VkPipelineRasterizationStateRasterizationOrderAMD32;

-typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32 +typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t maxGraphicsShaderGroupCount; - uint32_t maxIndirectSequenceCount; - uint32_t maxIndirectCommandsTokenCount; - uint32_t maxIndirectCommandsStreamCount; - uint32_t maxIndirectCommandsTokenOffset; - uint32_t maxIndirectCommandsStreamStride; - uint32_t minSequencesCountBufferOffsetAlignment; - uint32_t minSequencesIndexBufferOffsetAlignment; - uint32_t minIndirectCommandsBufferOffsetAlignment; -} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32; + VkPipelineRasterizationStateStreamCreateFlagsEXT flags; + uint32_t rasterizationStream; +} VkPipelineRasterizationStateStreamCreateInfoEXT32; + +typedef struct VkPipelineRenderingCreateInfo32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t viewMask; + uint32_t colorAttachmentCount; + PTR32 pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; +} VkPipelineRenderingCreateInfo32; +typedef VkPipelineRenderingCreateInfo32 VkPipelineRenderingCreateInfoKHR32;

-typedef struct VkPhysicalDeviceClusterAccelerationStructurePropertiesNV32 +typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - uint32_t maxVerticesPerCluster; - uint32_t maxTrianglesPerCluster; - uint32_t clusterScratchByteAlignment; - uint32_t clusterByteAlignment; - uint32_t clusterTemplateByteAlignment; - uint32_t clusterBottomLevelByteAlignment; - uint32_t clusterTemplateBoundsByteAlignment; - uint32_t maxClusterGeometryIndex; -} VkPhysicalDeviceClusterAccelerationStructurePropertiesNV32; + VkBool32 representativeFragmentTestEnable; +} VkPipelineRepresentativeFragmentTestStateCreateInfoNV32;

-typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT32 +typedef struct VkPipelineRobustnessCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t maxMultiDrawCount; -} VkPhysicalDeviceMultiDrawPropertiesEXT32; + VkPipelineRobustnessBufferBehavior storageBuffers; + VkPipelineRobustnessBufferBehavior uniformBuffers; + VkPipelineRobustnessBufferBehavior vertexInputs; + VkPipelineRobustnessImageBehavior images; +} VkPipelineRobustnessCreateInfo32; +typedef VkPipelineRobustnessCreateInfo32 VkPipelineRobustnessCreateInfoEXT32;

-typedef struct VkPhysicalDevicePushDescriptorProperties32 +typedef struct VkPipelineSampleLocationsStateCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t maxPushDescriptors; -} VkPhysicalDevicePushDescriptorProperties32; -typedef VkPhysicalDevicePushDescriptorProperties32 VkPhysicalDevicePushDescriptorPropertiesKHR32; + VkBool32 sampleLocationsEnable; + VkSampleLocationsInfoEXT32 sampleLocationsInfo; +} VkPipelineSampleLocationsStateCreateInfoEXT32;

-typedef struct VkPhysicalDeviceDriverProperties32 +typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkDriverId driverID; - char driverName[VK_MAX_DRIVER_NAME_SIZE]; - char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; - VkConformanceVersion conformanceVersion; -} VkPhysicalDeviceDriverProperties32; -typedef VkPhysicalDeviceDriverProperties32 VkPhysicalDeviceDriverPropertiesKHR32; + uint32_t identifierSize; + PTR32 pIdentifier; +} VkPipelineShaderStageModuleIdentifierCreateInfoEXT32;

-typedef struct VkPhysicalDeviceIDProperties32 +typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint8_t deviceUUID[VK_UUID_SIZE]; - uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE]; - uint32_t deviceNodeMask; - VkBool32 deviceLUIDValid; -} VkPhysicalDeviceIDProperties32; -typedef VkPhysicalDeviceIDProperties32 VkPhysicalDeviceIDPropertiesKHR32; + uint32_t requiredSubgroupSize; +} VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32; +typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT32; +typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 VkShaderRequiredSubgroupSizeCreateInfoEXT32;

-typedef struct VkPhysicalDeviceMultiviewProperties32 +typedef struct VkPipelineTessellationDomainOriginStateCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; -} VkPhysicalDeviceMultiviewProperties32; -typedef VkPhysicalDeviceMultiviewProperties32 VkPhysicalDeviceMultiviewPropertiesKHR32; + VkTessellationDomainOrigin domainOrigin; +} VkPipelineTessellationDomainOriginStateCreateInfo32; +typedef VkPipelineTessellationDomainOriginStateCreateInfo32 VkPipelineTessellationDomainOriginStateCreateInfoKHR32;

-typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT32 +typedef struct VkPipelineVertexInputDivisorStateCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t maxDiscardRectangles; -} VkPhysicalDeviceDiscardRectanglePropertiesEXT32; + uint32_t vertexBindingDivisorCount; + PTR32 pVertexBindingDivisors; +} VkPipelineVertexInputDivisorStateCreateInfo32; +typedef VkPipelineVertexInputDivisorStateCreateInfo32 VkPipelineVertexInputDivisorStateCreateInfoKHR32; +typedef VkPipelineVertexInputDivisorStateCreateInfo32 VkPipelineVertexInputDivisorStateCreateInfoEXT32;

-typedef struct VkPhysicalDeviceSubgroupProperties32 +typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - uint32_t subgroupSize; - VkShaderStageFlags supportedStages; - VkSubgroupFeatureFlags supportedOperations; - VkBool32 quadOperationsInAllStages; -} VkPhysicalDeviceSubgroupProperties32; + VkCoarseSampleOrderTypeNV sampleOrderType; + uint32_t customSampleOrderCount; + PTR32 pCustomSampleOrders; +} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32;

-typedef struct VkPhysicalDevicePointClippingProperties32 +typedef struct VkPipelineViewportDepthClampControlCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkPointClippingBehavior pointClippingBehavior; -} VkPhysicalDevicePointClippingProperties32; -typedef VkPhysicalDevicePointClippingProperties32 VkPhysicalDevicePointClippingPropertiesKHR32; + VkDepthClampModeEXT depthClampMode; + PTR32 pDepthClampRange; +} VkPipelineViewportDepthClampControlCreateInfoEXT32;

-typedef struct VkPhysicalDeviceProtectedMemoryProperties32 +typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 protectedNoFault; -} VkPhysicalDeviceProtectedMemoryProperties32; + VkBool32 negativeOneToOne; +} VkPipelineViewportDepthClipControlCreateInfoEXT32;

-typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties32 +typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkBool32 filterMinmaxSingleComponentFormats; - VkBool32 filterMinmaxImageComponentMapping; -} VkPhysicalDeviceSamplerFilterMinmaxProperties32; -typedef VkPhysicalDeviceSamplerFilterMinmaxProperties32 VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT32; + uint32_t exclusiveScissorCount; + PTR32 pExclusiveScissors; +} VkPipelineViewportExclusiveScissorStateCreateInfoNV32;

-typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT32 +typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkSampleCountFlags sampleLocationSampleCounts; - VkExtent2D maxSampleLocationGridSize; - float sampleLocationCoordinateRange[2]; - uint32_t sampleLocationSubPixelBits; - VkBool32 variableSampleLocations; -} VkPhysicalDeviceSampleLocationsPropertiesEXT32; + VkBool32 shadingRateImageEnable; + uint32_t viewportCount; + PTR32 pShadingRatePalettes; +} VkPipelineViewportShadingRateImageStateCreateInfoNV32;

-typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32 +typedef struct VkPipelineViewportSwizzleStateCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - uint32_t advancedBlendMaxColorAttachments; - VkBool32 advancedBlendIndependentBlend; - VkBool32 advancedBlendNonPremultipliedSrcColor; - VkBool32 advancedBlendNonPremultipliedDstColor; - VkBool32 advancedBlendCorrelatedOverlap; - VkBool32 advancedBlendAllOperations; -} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32; + VkPipelineViewportSwizzleStateCreateFlagsNV flags; + uint32_t viewportCount; + PTR32 pViewportSwizzles; +} VkPipelineViewportSwizzleStateCreateInfoNV32;

-typedef struct VkPhysicalDeviceInlineUniformBlockProperties32 +typedef struct VkPipelineViewportWScalingStateCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - uint32_t maxInlineUniformBlockSize; - uint32_t maxPerStageDescriptorInlineUniformBlocks; - uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; - uint32_t maxDescriptorSetInlineUniformBlocks; - uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; -} VkPhysicalDeviceInlineUniformBlockProperties32; -typedef VkPhysicalDeviceInlineUniformBlockProperties32 VkPhysicalDeviceInlineUniformBlockPropertiesEXT32; + VkBool32 viewportWScalingEnable; + uint32_t viewportCount; + PTR32 pViewportWScalings; +} VkPipelineViewportWScalingStateCreateInfoNV32;

-typedef struct VkPhysicalDeviceMaintenance3Properties32 +typedef struct VkPresentId2KHR32 { VkStructureType sType; PTR32 pNext; - uint32_t maxPerSetDescriptors; - VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize; -} VkPhysicalDeviceMaintenance3Properties32; -typedef VkPhysicalDeviceMaintenance3Properties32 VkPhysicalDeviceMaintenance3PropertiesKHR32; + uint32_t swapchainCount; + PTR32 pPresentIds; +} VkPresentId2KHR32;

-typedef struct VkPhysicalDeviceMaintenance4Properties32 +typedef struct VkPresentIdKHR32 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize; -} VkPhysicalDeviceMaintenance4Properties32; -typedef VkPhysicalDeviceMaintenance4Properties32 VkPhysicalDeviceMaintenance4PropertiesKHR32; + uint32_t swapchainCount; + PTR32 pPresentIds; +} VkPresentIdKHR32;

-typedef struct VkPhysicalDeviceMaintenance5Properties32 +typedef struct VkPresentInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; - VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; - VkBool32 depthStencilSwizzleOneSupport; - VkBool32 polygonModePointSize; - VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; - VkBool32 nonStrictWideLinesUseParallelogram; -} VkPhysicalDeviceMaintenance5Properties32; -typedef VkPhysicalDeviceMaintenance5Properties32 VkPhysicalDeviceMaintenance5PropertiesKHR32; + uint32_t waitSemaphoreCount; + PTR32 pWaitSemaphores; + uint32_t swapchainCount; + PTR32 pSwapchains; + PTR32 pImageIndices; + PTR32 pResults; +} VkPresentInfoKHR32;

-typedef struct VkPhysicalDeviceMaintenance6Properties32 +typedef struct VkPresentRegionsKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 blockTexelViewCompatibleMultipleLayers; - uint32_t maxCombinedImageSamplerDescriptorCount; - VkBool32 fragmentShadingRateClampCombinerInputs; -} VkPhysicalDeviceMaintenance6Properties32; -typedef VkPhysicalDeviceMaintenance6Properties32 VkPhysicalDeviceMaintenance6PropertiesKHR32; + uint32_t swapchainCount; + PTR32 pRegions; +} VkPresentRegionsKHR32;

-typedef struct VkPhysicalDeviceMaintenance9PropertiesKHR32 +typedef struct VkPresentWait2InfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 image2DViewOf3DSparse; - VkDefaultVertexAttributeValueKHR defaultVertexAttributeValue; -} VkPhysicalDeviceMaintenance9PropertiesKHR32; + uint64_t DECLSPEC_ALIGN(8) presentId; + uint64_t DECLSPEC_ALIGN(8) timeout; +} VkPresentWait2InfoKHR32;

-typedef struct VkPhysicalDeviceFloatControlsProperties32 +typedef struct VkPrivateDataSlotCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkShaderFloatControlsIndependence denormBehaviorIndependence; - VkShaderFloatControlsIndependence roundingModeIndependence; - VkBool32 shaderSignedZeroInfNanPreserveFloat16; - VkBool32 shaderSignedZeroInfNanPreserveFloat32; - VkBool32 shaderSignedZeroInfNanPreserveFloat64; - VkBool32 shaderDenormPreserveFloat16; - VkBool32 shaderDenormPreserveFloat32; - VkBool32 shaderDenormPreserveFloat64; - VkBool32 shaderDenormFlushToZeroFloat16; - VkBool32 shaderDenormFlushToZeroFloat32; - VkBool32 shaderDenormFlushToZeroFloat64; - VkBool32 shaderRoundingModeRTEFloat16; - VkBool32 shaderRoundingModeRTEFloat32; - VkBool32 shaderRoundingModeRTEFloat64; - VkBool32 shaderRoundingModeRTZFloat16; - VkBool32 shaderRoundingModeRTZFloat32; - VkBool32 shaderRoundingModeRTZFloat64; -} VkPhysicalDeviceFloatControlsProperties32; -typedef VkPhysicalDeviceFloatControlsProperties32 VkPhysicalDeviceFloatControlsPropertiesKHR32; + VkPrivateDataSlotCreateFlags flags; +} VkPrivateDataSlotCreateInfo32; +typedef VkPrivateDataSlotCreateInfo32 VkPrivateDataSlotCreateInfoEXT32;

-typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT32 +typedef struct VkProtectedSubmitInfo32 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) minImportedHostPointerAlignment; -} VkPhysicalDeviceExternalMemoryHostPropertiesEXT32; + VkBool32 protectedSubmit; +} VkProtectedSubmitInfo32;

-typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT32 +typedef struct VkPushConstantsInfo32 { VkStructureType sType; PTR32 pNext; - float primitiveOverestimationSize; - float maxExtraPrimitiveOverestimationSize; - float extraPrimitiveOverestimationSizeGranularity; - VkBool32 primitiveUnderestimation; - VkBool32 conservativePointAndLineRasterization; - VkBool32 degenerateTrianglesRasterized; - VkBool32 degenerateLinesRasterized; - VkBool32 fullyCoveredFragmentShaderInputVariable; - VkBool32 conservativeRasterizationPostDepthCoverage; -} VkPhysicalDeviceConservativeRasterizationPropertiesEXT32; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; + PTR32 pValues; +} VkPushConstantsInfo32; +typedef VkPushConstantsInfo32 VkPushConstantsInfoKHR32;

-typedef struct VkPhysicalDeviceShaderCorePropertiesAMD32 +typedef struct VkPushDescriptorSetInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t shaderEngineCount; - uint32_t shaderArraysPerEngineCount; - uint32_t computeUnitsPerShaderArray; - uint32_t simdPerComputeUnit; - uint32_t wavefrontsPerSimd; - uint32_t wavefrontSize; - uint32_t sgprsPerSimd; - uint32_t minSgprAllocation; - uint32_t maxSgprAllocation; - uint32_t sgprAllocationGranularity; - uint32_t vgprsPerSimd; - uint32_t minVgprAllocation; - uint32_t maxVgprAllocation; - uint32_t vgprAllocationGranularity; -} VkPhysicalDeviceShaderCorePropertiesAMD32; + VkShaderStageFlags stageFlags; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t set; + uint32_t descriptorWriteCount; + PTR32 pDescriptorWrites; +} VkPushDescriptorSetInfo32; +typedef VkPushDescriptorSetInfo32 VkPushDescriptorSetInfoKHR32;

-typedef struct VkPhysicalDeviceShaderCoreProperties2AMD32 +typedef struct VkPushDescriptorSetWithTemplateInfo32 { VkStructureType sType; PTR32 pNext; - VkShaderCorePropertiesFlagsAMD shaderCoreFeatures; - uint32_t activeComputeUnitCount; -} VkPhysicalDeviceShaderCoreProperties2AMD32; + VkDescriptorUpdateTemplate DECLSPEC_ALIGN(8) descriptorUpdateTemplate; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t set; + PTR32 pData; +} VkPushDescriptorSetWithTemplateInfo32; +typedef VkPushDescriptorSetWithTemplateInfo32 VkPushDescriptorSetWithTemplateInfoKHR32;

-typedef struct VkPhysicalDeviceDescriptorIndexingProperties32 +typedef struct VkQueryLowLatencySupportNV32 { VkStructureType sType; PTR32 pNext; - uint32_t maxUpdateAfterBindDescriptorsInAllPools; - VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; - VkBool32 shaderSampledImageArrayNonUniformIndexingNative; - VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; - VkBool32 shaderStorageImageArrayNonUniformIndexingNative; - VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; - VkBool32 robustBufferAccessUpdateAfterBind; - VkBool32 quadDivergentImplicitLod; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; - uint32_t maxPerStageUpdateAfterBindResources; - uint32_t maxDescriptorSetUpdateAfterBindSamplers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; -} VkPhysicalDeviceDescriptorIndexingProperties32; -typedef VkPhysicalDeviceDescriptorIndexingProperties32 VkPhysicalDeviceDescriptorIndexingPropertiesEXT32; + PTR32 pQueriedLowLatencyData; +} VkQueryLowLatencySupportNV32;

-typedef struct VkPhysicalDeviceTimelineSemaphoreProperties32 +typedef struct VkQueryPoolCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference; -} VkPhysicalDeviceTimelineSemaphoreProperties32; -typedef VkPhysicalDeviceTimelineSemaphoreProperties32 VkPhysicalDeviceTimelineSemaphorePropertiesKHR32; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint32_t queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo32;

-typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32 +typedef struct VkQueryPoolPerformanceCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t maxVertexAttribDivisor; -} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32; + uint32_t queueFamilyIndex; + uint32_t counterIndexCount; + PTR32 pCounterIndices; +} VkQueryPoolPerformanceCreateInfoKHR32;

-typedef struct VkPhysicalDeviceVertexAttributeDivisorProperties32 +typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL32 { VkStructureType sType; PTR32 pNext; - uint32_t maxVertexAttribDivisor; - VkBool32 supportsNonZeroFirstInstance; -} VkPhysicalDeviceVertexAttributeDivisorProperties32; -typedef VkPhysicalDeviceVertexAttributeDivisorProperties32 VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR32; + VkQueryPoolSamplingModeINTEL performanceCountersSampling; +} VkQueryPoolPerformanceQueryCreateInfoINTEL32; +typedef VkQueryPoolPerformanceQueryCreateInfoINTEL32 VkQueryPoolCreateInfoINTEL32;

-typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT32 +typedef struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t pciDomain; - uint32_t pciBus; - uint32_t pciDevice; - uint32_t pciFunction; -} VkPhysicalDevicePCIBusInfoPropertiesEXT32; + VkVideoEncodeFeedbackFlagsKHR encodeFeedbackFlags; +} VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32;

-typedef struct VkPhysicalDeviceDepthStencilResolveProperties32 +typedef struct VkQueueFamilyCheckpointProperties2NV32 { VkStructureType sType; PTR32 pNext; - VkResolveModeFlags supportedDepthResolveModes; - VkResolveModeFlags supportedStencilResolveModes; - VkBool32 independentResolveNone; - VkBool32 independentResolve; -} VkPhysicalDeviceDepthStencilResolveProperties32; -typedef VkPhysicalDeviceDepthStencilResolveProperties32 VkPhysicalDeviceDepthStencilResolvePropertiesKHR32; + VkPipelineStageFlags2 DECLSPEC_ALIGN(8) checkpointExecutionStageMask; +} VkQueueFamilyCheckpointProperties2NV32;

-typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT32 +typedef struct VkQueueFamilyCheckpointPropertiesNV32 { VkStructureType sType; PTR32 pNext; - uint32_t maxTransformFeedbackStreams; - uint32_t maxTransformFeedbackBuffers; - VkDeviceSize DECLSPEC_ALIGN(8) maxTransformFeedbackBufferSize; - uint32_t maxTransformFeedbackStreamDataSize; - uint32_t maxTransformFeedbackBufferDataSize; - uint32_t maxTransformFeedbackBufferDataStride; - VkBool32 transformFeedbackQueries; - VkBool32 transformFeedbackStreamsLinesTriangles; - VkBool32 transformFeedbackRasterizationStreamSelect; - VkBool32 transformFeedbackDraw; -} VkPhysicalDeviceTransformFeedbackPropertiesEXT32; + VkPipelineStageFlags checkpointExecutionStageMask; +} VkQueueFamilyCheckpointPropertiesNV32;

-typedef struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32 +typedef struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 meshAndTaskShaderDerivatives; -} VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32; + VkExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes; + VkExternalMemoryHandleTypeFlags foreignMemoryHandleTypes; +} VkQueueFamilyDataGraphProcessingEnginePropertiesARM32;

-typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 +typedef struct VkQueueFamilyDataGraphPropertiesARM32 { VkStructureType sType; PTR32 pNext; - VkQueueFlags supportedQueues; -} VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32; + VkPhysicalDeviceDataGraphProcessingEngineARM engine; + VkPhysicalDeviceDataGraphOperationSupportARM operation; +} VkQueueFamilyDataGraphPropertiesARM32;

-typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV32 +typedef struct VkQueueFamilyGlobalPriorityProperties32 { VkStructureType sType; PTR32 pNext; - VkMemoryDecompressionMethodFlagsNV DECLSPEC_ALIGN(8) decompressionMethods; - uint64_t DECLSPEC_ALIGN(8) maxDecompressionIndirectCount; -} VkPhysicalDeviceMemoryDecompressionPropertiesNV32; + uint32_t priorityCount; + VkQueueGlobalPriority priorities[VK_MAX_GLOBAL_PRIORITY_SIZE]; +} VkQueueFamilyGlobalPriorityProperties32; +typedef VkQueueFamilyGlobalPriorityProperties32 VkQueueFamilyGlobalPriorityPropertiesKHR32; +typedef VkQueueFamilyGlobalPriorityProperties32 VkQueueFamilyGlobalPriorityPropertiesEXT32;

-typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV32 +typedef struct VkQueueFamilyOwnershipTransferPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - VkExtent2D shadingRateTexelSize; - uint32_t shadingRatePaletteSize; - uint32_t shadingRateMaxCoarseSamples; -} VkPhysicalDeviceShadingRateImagePropertiesNV32; + uint32_t optimalImageTransferToQueueFamilies; +} VkQueueFamilyOwnershipTransferPropertiesKHR32;

-typedef struct VkPhysicalDeviceMeshShaderPropertiesNV32 +typedef struct VkQueueFamilyProperties232 { VkStructureType sType; PTR32 pNext; - uint32_t maxDrawMeshTasksCount; - uint32_t maxTaskWorkGroupInvocations; - uint32_t maxTaskWorkGroupSize[3]; - uint32_t maxTaskTotalMemorySize; - uint32_t maxTaskOutputCount; - uint32_t maxMeshWorkGroupInvocations; - uint32_t maxMeshWorkGroupSize[3]; - uint32_t maxMeshTotalMemorySize; - uint32_t maxMeshOutputVertices; - uint32_t maxMeshOutputPrimitives; - uint32_t maxMeshMultiviewViewCount; - uint32_t meshOutputPerVertexGranularity; - uint32_t meshOutputPerPrimitiveGranularity; -} VkPhysicalDeviceMeshShaderPropertiesNV32; + VkQueueFamilyProperties queueFamilyProperties; +} VkQueueFamilyProperties232; +typedef VkQueueFamilyProperties232 VkQueueFamilyProperties2KHR32;

-typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT32 +typedef struct VkQueueFamilyQueryResultStatusPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t maxTaskWorkGroupTotalCount; - uint32_t maxTaskWorkGroupCount[3]; - uint32_t maxTaskWorkGroupInvocations; - uint32_t maxTaskWorkGroupSize[3]; - uint32_t maxTaskPayloadSize; - uint32_t maxTaskSharedMemorySize; - uint32_t maxTaskPayloadAndSharedMemorySize; - uint32_t maxMeshWorkGroupTotalCount; - uint32_t maxMeshWorkGroupCount[3]; - uint32_t maxMeshWorkGroupInvocations; - uint32_t maxMeshWorkGroupSize[3]; - uint32_t maxMeshSharedMemorySize; - uint32_t maxMeshPayloadAndSharedMemorySize; - uint32_t maxMeshOutputMemorySize; - uint32_t maxMeshPayloadAndOutputMemorySize; - uint32_t maxMeshOutputComponents; - uint32_t maxMeshOutputVertices; - uint32_t maxMeshOutputPrimitives; - uint32_t maxMeshOutputLayers; - uint32_t maxMeshMultiviewViewCount; - uint32_t meshOutputPerVertexGranularity; - uint32_t meshOutputPerPrimitiveGranularity; - uint32_t maxPreferredTaskWorkGroupInvocations; - uint32_t maxPreferredMeshWorkGroupInvocations; - VkBool32 prefersLocalInvocationVertexOutput; - VkBool32 prefersLocalInvocationPrimitiveOutput; - VkBool32 prefersCompactVertexOutput; - VkBool32 prefersCompactPrimitiveOutput; -} VkPhysicalDeviceMeshShaderPropertiesEXT32; + VkBool32 queryResultStatusSupport; +} VkQueueFamilyQueryResultStatusPropertiesKHR32;

-typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR32 +typedef struct VkQueueFamilyVideoPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - uint64_t DECLSPEC_ALIGN(8) maxGeometryCount; - uint64_t DECLSPEC_ALIGN(8) maxInstanceCount; - uint64_t DECLSPEC_ALIGN(8) maxPrimitiveCount; - uint32_t maxPerStageDescriptorAccelerationStructures; - uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures; - uint32_t maxDescriptorSetAccelerationStructures; - uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures; - uint32_t minAccelerationStructureScratchOffsetAlignment; -} VkPhysicalDeviceAccelerationStructurePropertiesKHR32; + VkVideoCodecOperationFlagsKHR videoCodecOperations; +} VkQueueFamilyVideoPropertiesKHR32;

-typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR32 +typedef struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - uint32_t shaderGroupHandleSize; - uint32_t maxRayRecursionDepth; - uint32_t maxShaderGroupStride; - uint32_t shaderGroupBaseAlignment; - uint32_t shaderGroupHandleCaptureReplaySize; - uint32_t maxRayDispatchInvocationCount; - uint32_t shaderGroupHandleAlignment; - uint32_t maxRayHitAttributeSize; -} VkPhysicalDeviceRayTracingPipelinePropertiesKHR32; + VkBool32 allowClusterAccelerationStructure; +} VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32;

-typedef struct VkPhysicalDeviceRayTracingPropertiesNV32 +typedef struct VkRayTracingPipelineCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t shaderGroupHandleSize; - uint32_t maxRecursionDepth; - uint32_t maxShaderGroupStride; - uint32_t shaderGroupBaseAlignment; - uint64_t DECLSPEC_ALIGN(8) maxGeometryCount; - uint64_t DECLSPEC_ALIGN(8) maxInstanceCount; - uint64_t DECLSPEC_ALIGN(8) maxTriangleCount; - uint32_t maxDescriptorSetAccelerationStructures; -} VkPhysicalDeviceRayTracingPropertiesNV32; + VkPipelineCreateFlags flags; + uint32_t stageCount; + PTR32 pStages; + uint32_t groupCount; + PTR32 pGroups; + uint32_t maxPipelineRayRecursionDepth; + PTR32 pLibraryInfo; + PTR32 pLibraryInterface; + PTR32 pDynamicState; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle; + int32_t basePipelineIndex; +} VkRayTracingPipelineCreateInfoKHR32;

-typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT32 +typedef struct VkRayTracingPipelineCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkExtent2D minFragmentDensityTexelSize; - VkExtent2D maxFragmentDensityTexelSize; - VkBool32 fragmentDensityInvocations; -} VkPhysicalDeviceFragmentDensityMapPropertiesEXT32; + VkPipelineCreateFlags flags; + uint32_t stageCount; + PTR32 pStages; + uint32_t groupCount; + PTR32 pGroups; + uint32_t maxRecursionDepth; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + VkPipeline DECLSPEC_ALIGN(8) basePipelineHandle; + int32_t basePipelineIndex; +} VkRayTracingPipelineCreateInfoNV32;

-typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32 +typedef struct VkReleaseCapturedPipelineDataInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 subsampledLoads; - VkBool32 subsampledCoarseReconstructionEarlyAccess; - uint32_t maxSubsampledArrayLayers; - uint32_t maxDescriptorSetSubsampledSamplers; -} VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32; + VkPipeline DECLSPEC_ALIGN(8) pipeline; +} VkReleaseCapturedPipelineDataInfoKHR32;

-typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32 +typedef struct VkReleaseSwapchainImagesInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkExtent2D fragmentDensityOffsetGranularity; -} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32; -typedef VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32 VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM32; + VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; + uint32_t imageIndexCount; + PTR32 pImageIndices; +} VkReleaseSwapchainImagesInfoKHR32; +typedef VkReleaseSwapchainImagesInfoKHR32 VkReleaseSwapchainImagesInfoEXT32;

-typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV32 +typedef struct VkRenderPassAttachmentBeginInfo32 { VkStructureType sType; PTR32 pNext; - VkShaderStageFlags cooperativeMatrixSupportedStages; -} VkPhysicalDeviceCooperativeMatrixPropertiesNV32; + uint32_t attachmentCount; + PTR32 pAttachments; +} VkRenderPassAttachmentBeginInfo32; +typedef VkRenderPassAttachmentBeginInfo32 VkRenderPassAttachmentBeginInfoKHR32;

-typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR32 +typedef struct VkRenderPassBeginInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 allowCommandBufferQueryCopies; -} VkPhysicalDevicePerformanceQueryPropertiesKHR32; + VkRenderPass DECLSPEC_ALIGN(8) renderPass; + VkFramebuffer DECLSPEC_ALIGN(8) framebuffer; + VkRect2D renderArea; + uint32_t clearValueCount; + PTR32 pClearValues; +} VkRenderPassBeginInfo32;

-typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32 +typedef struct VkRenderPassCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t shaderSMCount; - uint32_t shaderWarpsPerSM; -} VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + PTR32 pAttachments; + uint32_t subpassCount; + PTR32 pSubpasses; + uint32_t dependencyCount; + PTR32 pDependencies; +} VkRenderPassCreateInfo32;

-typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties32 +typedef struct VkRenderPassCreateInfo232 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes; - VkBool32 storageTexelBufferOffsetSingleTexelAlignment; - VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes; - VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; -} VkPhysicalDeviceTexelBufferAlignmentProperties32; -typedef VkPhysicalDeviceTexelBufferAlignmentProperties32 VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT32; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + PTR32 pAttachments; + uint32_t subpassCount; + PTR32 pSubpasses; + uint32_t dependencyCount; + PTR32 pDependencies; + uint32_t correlatedViewMaskCount; + PTR32 pCorrelatedViewMasks; +} VkRenderPassCreateInfo232; +typedef VkRenderPassCreateInfo232 VkRenderPassCreateInfo2KHR32;

-typedef struct VkPhysicalDeviceSubgroupSizeControlProperties32 +typedef struct VkRenderPassCreationControlEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t minSubgroupSize; - uint32_t maxSubgroupSize; - uint32_t maxComputeWorkgroupSubgroups; - VkShaderStageFlags requiredSubgroupSizeStages; -} VkPhysicalDeviceSubgroupSizeControlProperties32; -typedef VkPhysicalDeviceSubgroupSizeControlProperties32 VkPhysicalDeviceSubgroupSizeControlPropertiesEXT32; + VkBool32 disallowMerging; +} VkRenderPassCreationControlEXT32;

-typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32 +typedef struct VkRenderPassCreationFeedbackCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t maxSubpassShadingWorkgroupSizeAspectRatio; -} VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32; + PTR32 pRenderPassFeedback; +} VkRenderPassCreationFeedbackCreateInfoEXT32;

-typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32 +typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t maxWorkGroupCount[3]; - uint32_t maxWorkGroupSize[3]; - uint32_t maxOutputClusterCount; - VkDeviceSize DECLSPEC_ALIGN(8) indirectBufferOffsetAlignment; -} VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32; + VkAttachmentReference fragmentDensityMapAttachment; +} VkRenderPassFragmentDensityMapCreateInfoEXT32;

-typedef struct VkPhysicalDeviceLineRasterizationProperties32 +typedef struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t lineSubPixelPrecisionBits; -} VkPhysicalDeviceLineRasterizationProperties32; -typedef VkPhysicalDeviceLineRasterizationProperties32 VkPhysicalDeviceLineRasterizationPropertiesKHR32; -typedef VkPhysicalDeviceLineRasterizationProperties32 VkPhysicalDeviceLineRasterizationPropertiesEXT32; + uint32_t fragmentDensityOffsetCount; + PTR32 pFragmentDensityOffsets; +} VkRenderPassFragmentDensityMapOffsetEndInfoEXT32; +typedef VkRenderPassFragmentDensityMapOffsetEndInfoEXT32 VkSubpassFragmentDensityMapOffsetEndInfoQCOM32;

-typedef struct VkPhysicalDeviceVulkan11Properties32 +typedef struct VkRenderPassInputAttachmentAspectCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint8_t deviceUUID[VK_UUID_SIZE]; - uint8_t driverUUID[VK_UUID_SIZE]; - uint8_t deviceLUID[VK_LUID_SIZE]; - uint32_t deviceNodeMask; - VkBool32 deviceLUIDValid; - uint32_t subgroupSize; - VkShaderStageFlags subgroupSupportedStages; - VkSubgroupFeatureFlags subgroupSupportedOperations; - VkBool32 subgroupQuadOperationsInAllStages; - VkPointClippingBehavior pointClippingBehavior; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; - VkBool32 protectedNoFault; - uint32_t maxPerSetDescriptors; - VkDeviceSize DECLSPEC_ALIGN(8) maxMemoryAllocationSize; -} VkPhysicalDeviceVulkan11Properties32; + uint32_t aspectReferenceCount; + PTR32 pAspectReferences; +} VkRenderPassInputAttachmentAspectCreateInfo32; +typedef VkRenderPassInputAttachmentAspectCreateInfo32 VkRenderPassInputAttachmentAspectCreateInfoKHR32;

-typedef struct VkPhysicalDeviceVulkan12Properties32 +typedef struct VkRenderPassMultiviewCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkDriverId driverID; - char driverName[VK_MAX_DRIVER_NAME_SIZE]; - char driverInfo[VK_MAX_DRIVER_INFO_SIZE]; - VkConformanceVersion conformanceVersion; - VkShaderFloatControlsIndependence denormBehaviorIndependence; - VkShaderFloatControlsIndependence roundingModeIndependence; - VkBool32 shaderSignedZeroInfNanPreserveFloat16; - VkBool32 shaderSignedZeroInfNanPreserveFloat32; - VkBool32 shaderSignedZeroInfNanPreserveFloat64; - VkBool32 shaderDenormPreserveFloat16; - VkBool32 shaderDenormPreserveFloat32; - VkBool32 shaderDenormPreserveFloat64; - VkBool32 shaderDenormFlushToZeroFloat16; - VkBool32 shaderDenormFlushToZeroFloat32; - VkBool32 shaderDenormFlushToZeroFloat64; - VkBool32 shaderRoundingModeRTEFloat16; - VkBool32 shaderRoundingModeRTEFloat32; - VkBool32 shaderRoundingModeRTEFloat64; - VkBool32 shaderRoundingModeRTZFloat16; - VkBool32 shaderRoundingModeRTZFloat32; - VkBool32 shaderRoundingModeRTZFloat64; - uint32_t maxUpdateAfterBindDescriptorsInAllPools; - VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; - VkBool32 shaderSampledImageArrayNonUniformIndexingNative; - VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; - VkBool32 shaderStorageImageArrayNonUniformIndexingNative; - VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; - VkBool32 robustBufferAccessUpdateAfterBind; - VkBool32 quadDivergentImplicitLod; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; - uint32_t maxPerStageUpdateAfterBindResources; - uint32_t maxDescriptorSetUpdateAfterBindSamplers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; - VkResolveModeFlags supportedDepthResolveModes; - VkResolveModeFlags supportedStencilResolveModes; - VkBool32 independentResolveNone; - VkBool32 independentResolve; - VkBool32 filterMinmaxSingleComponentFormats; - VkBool32 filterMinmaxImageComponentMapping; - uint64_t DECLSPEC_ALIGN(8) maxTimelineSemaphoreValueDifference; - VkSampleCountFlags framebufferIntegerColorSampleCounts; -} VkPhysicalDeviceVulkan12Properties32; + uint32_t subpassCount; + PTR32 pViewMasks; + uint32_t dependencyCount; + PTR32 pViewOffsets; + uint32_t correlationMaskCount; + PTR32 pCorrelationMasks; +} VkRenderPassMultiviewCreateInfo32; +typedef VkRenderPassMultiviewCreateInfo32 VkRenderPassMultiviewCreateInfoKHR32;

-typedef struct VkPhysicalDeviceVulkan13Properties32 -{ - VkStructureType sType; - PTR32 pNext; - uint32_t minSubgroupSize; - uint32_t maxSubgroupSize; - uint32_t maxComputeWorkgroupSubgroups; - VkShaderStageFlags requiredSubgroupSizeStages; - uint32_t maxInlineUniformBlockSize; - uint32_t maxPerStageDescriptorInlineUniformBlocks; - uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; - uint32_t maxDescriptorSetInlineUniformBlocks; - uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; - uint32_t maxInlineUniformTotalSize; - VkBool32 integerDotProduct8BitUnsignedAccelerated; - VkBool32 integerDotProduct8BitSignedAccelerated; - VkBool32 integerDotProduct8BitMixedSignednessAccelerated; - VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProduct16BitUnsignedAccelerated; - VkBool32 integerDotProduct16BitSignedAccelerated; - VkBool32 integerDotProduct16BitMixedSignednessAccelerated; - VkBool32 integerDotProduct32BitUnsignedAccelerated; - VkBool32 integerDotProduct32BitSignedAccelerated; - VkBool32 integerDotProduct32BitMixedSignednessAccelerated; - VkBool32 integerDotProduct64BitUnsignedAccelerated; - VkBool32 integerDotProduct64BitSignedAccelerated; - VkBool32 integerDotProduct64BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; - VkDeviceSize DECLSPEC_ALIGN(8) storageTexelBufferOffsetAlignmentBytes; - VkBool32 storageTexelBufferOffsetSingleTexelAlignment; - VkDeviceSize DECLSPEC_ALIGN(8) uniformTexelBufferOffsetAlignmentBytes; - VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; - VkDeviceSize DECLSPEC_ALIGN(8) maxBufferSize; -} VkPhysicalDeviceVulkan13Properties32; +typedef struct VkRenderPassSampleLocationsBeginInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + uint32_t attachmentInitialSampleLocationsCount; + PTR32 pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + PTR32 pPostSubpassSampleLocations; +} VkRenderPassSampleLocationsBeginInfoEXT32;

-typedef struct VkPhysicalDeviceVulkan14Properties32 +typedef struct VkRenderPassStripeBeginInfoARM32 { VkStructureType sType; PTR32 pNext; - uint32_t lineSubPixelPrecisionBits; - uint32_t maxVertexAttribDivisor; - VkBool32 supportsNonZeroFirstInstance; - uint32_t maxPushDescriptors; - VkBool32 dynamicRenderingLocalReadDepthStencilAttachments; - VkBool32 dynamicRenderingLocalReadMultisampledAttachments; - VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; - VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; - VkBool32 depthStencilSwizzleOneSupport; - VkBool32 polygonModePointSize; - VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; - VkBool32 nonStrictWideLinesUseParallelogram; - VkBool32 blockTexelViewCompatibleMultipleLayers; - uint32_t maxCombinedImageSamplerDescriptorCount; - VkBool32 fragmentShadingRateClampCombinerInputs; - VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers; - VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers; - VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs; - VkPipelineRobustnessImageBehavior defaultRobustnessImages; - uint32_t copySrcLayoutCount; - PTR32 pCopySrcLayouts; - uint32_t copyDstLayoutCount; - PTR32 pCopyDstLayouts; - uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; - VkBool32 identicalMemoryTypeRequirements; -} VkPhysicalDeviceVulkan14Properties32; + uint32_t stripeInfoCount; + PTR32 pStripeInfos; +} VkRenderPassStripeBeginInfoARM32;

-typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT32 +typedef struct VkRenderPassStripeSubmitInfoARM32 { VkStructureType sType; PTR32 pNext; - uint32_t maxCustomBorderColorSamplers; -} VkPhysicalDeviceCustomBorderColorPropertiesEXT32; + uint32_t stripeSemaphoreInfoCount; + PTR32 pStripeSemaphoreInfos; +} VkRenderPassStripeSubmitInfoARM32;

-typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 +typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 dynamicPrimitiveTopologyUnrestricted; -} VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32; + PTR32 pSubpassFeedback; +} VkRenderPassSubpassFeedbackCreateInfoEXT32;

-typedef struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV32 +typedef struct VkRenderPassTileShadingCreateInfoQCOM32 { VkStructureType sType; PTR32 pNext; - uint32_t maxPartitionCount; -} VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV32; + VkTileShadingRenderPassFlagsQCOM flags; + VkExtent2D tileApronSize; +} VkRenderPassTileShadingCreateInfoQCOM32;

-typedef struct VkPhysicalDeviceRobustness2PropertiesKHR32 +typedef struct VkRenderPassTransformBeginInfoQCOM32 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) robustStorageBufferAccessSizeAlignment; - VkDeviceSize DECLSPEC_ALIGN(8) robustUniformBufferAccessSizeAlignment; -} VkPhysicalDeviceRobustness2PropertiesKHR32; -typedef VkPhysicalDeviceRobustness2PropertiesKHR32 VkPhysicalDeviceRobustness2PropertiesEXT32; + VkSurfaceTransformFlagBitsKHR transform; +} VkRenderPassTransformBeginInfoQCOM32;

-typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR32 +typedef struct VkRenderingAreaInfo32 { VkStructureType sType; PTR32 pNext; - VkExtent2D minFragmentShadingRateAttachmentTexelSize; - VkExtent2D maxFragmentShadingRateAttachmentTexelSize; - uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; - VkBool32 primitiveFragmentShadingRateWithMultipleViewports; - VkBool32 layeredShadingRateAttachments; - VkBool32 fragmentShadingRateNonTrivialCombinerOps; - VkExtent2D maxFragmentSize; - uint32_t maxFragmentSizeAspectRatio; - uint32_t maxFragmentShadingRateCoverageSamples; - VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; - VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; - VkBool32 fragmentShadingRateWithSampleMask; - VkBool32 fragmentShadingRateWithShaderSampleMask; - VkBool32 fragmentShadingRateWithConservativeRasterization; - VkBool32 fragmentShadingRateWithFragmentShaderInterlock; - VkBool32 fragmentShadingRateWithCustomSampleLocations; - VkBool32 fragmentShadingRateStrictMultiplyCombiner; -} VkPhysicalDeviceFragmentShadingRatePropertiesKHR32; + uint32_t viewMask; + uint32_t colorAttachmentCount; + PTR32 pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; +} VkRenderingAreaInfo32; +typedef VkRenderingAreaInfo32 VkRenderingAreaInfoKHR32;

-typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 +typedef struct VkRenderingAttachmentLocationInfo32 { VkStructureType sType; PTR32 pNext; - VkSampleCountFlagBits maxFragmentShadingRateInvocationCount; -} VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32; + uint32_t colorAttachmentCount; + PTR32 pColorAttachmentLocations; +} VkRenderingAttachmentLocationInfo32; +typedef VkRenderingAttachmentLocationInfo32 VkRenderingAttachmentLocationInfoKHR32;

-typedef struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32 +typedef struct VkRenderingEndInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 nativeUnalignedPerformance; -} VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32; +} VkRenderingEndInfoEXT32;

-typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32 +typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t maxIndirectPipelineCount; - uint32_t maxIndirectShaderObjectCount; - uint32_t maxIndirectSequenceCount; - uint32_t maxIndirectCommandsTokenCount; - uint32_t maxIndirectCommandsTokenOffset; - uint32_t maxIndirectCommandsIndirectStride; - VkIndirectCommandsInputModeFlagsEXT supportedIndirectCommandsInputModes; - VkShaderStageFlags supportedIndirectCommandsShaderStages; - VkShaderStageFlags supportedIndirectCommandsShaderStagesPipelineBinding; - VkShaderStageFlags supportedIndirectCommandsShaderStagesShaderBinding; - VkBool32 deviceGeneratedCommandsTransformFeedback; - VkBool32 deviceGeneratedCommandsMultiDrawIndirectCount; -} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32; + VkImageView DECLSPEC_ALIGN(8) imageView; + VkImageLayout imageLayout; +} VkRenderingFragmentDensityMapAttachmentInfoEXT32;

-typedef struct VkPhysicalDeviceHostImageCopyProperties32 +typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t copySrcLayoutCount; - PTR32 pCopySrcLayouts; - uint32_t copyDstLayoutCount; - PTR32 pCopyDstLayouts; - uint8_t optimalTilingLayoutUUID[VK_UUID_SIZE]; - VkBool32 identicalMemoryTypeRequirements; -} VkPhysicalDeviceHostImageCopyProperties32; -typedef VkPhysicalDeviceHostImageCopyProperties32 VkPhysicalDeviceHostImageCopyPropertiesEXT32; + VkImageView DECLSPEC_ALIGN(8) imageView; + VkImageLayout imageLayout; + VkExtent2D shadingRateAttachmentTexelSize; +} VkRenderingFragmentShadingRateAttachmentInfoKHR32;

-typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT32 +typedef struct VkRenderingInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 provokingVertexModePerPipeline; - VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex; -} VkPhysicalDeviceProvokingVertexPropertiesEXT32; + VkRenderingFlags flags; + VkRect2D renderArea; + uint32_t layerCount; + uint32_t viewMask; + uint32_t colorAttachmentCount; + PTR32 pColorAttachments; + PTR32 pDepthAttachment; + PTR32 pStencilAttachment; +} VkRenderingInfo32; +typedef VkRenderingInfo32 VkRenderingInfoKHR32;

-typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT32 +typedef struct VkRenderingInputAttachmentIndexInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 combinedImageSamplerDescriptorSingleArray; - VkBool32 bufferlessPushDescriptors; - VkBool32 allowSamplerImageViewPostSubmitCreation; - VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferOffsetAlignment; - uint32_t maxDescriptorBufferBindings; - uint32_t maxResourceDescriptorBufferBindings; - uint32_t maxSamplerDescriptorBufferBindings; - uint32_t maxEmbeddedImmutableSamplerBindings; - uint32_t maxEmbeddedImmutableSamplers; - PTR32 bufferCaptureReplayDescriptorDataSize; - PTR32 imageCaptureReplayDescriptorDataSize; - PTR32 imageViewCaptureReplayDescriptorDataSize; - PTR32 samplerCaptureReplayDescriptorDataSize; - PTR32 accelerationStructureCaptureReplayDescriptorDataSize; - PTR32 samplerDescriptorSize; - PTR32 combinedImageSamplerDescriptorSize; - PTR32 sampledImageDescriptorSize; - PTR32 storageImageDescriptorSize; - PTR32 uniformTexelBufferDescriptorSize; - PTR32 robustUniformTexelBufferDescriptorSize; - PTR32 storageTexelBufferDescriptorSize; - PTR32 robustStorageTexelBufferDescriptorSize; - PTR32 uniformBufferDescriptorSize; - PTR32 robustUniformBufferDescriptorSize; - PTR32 storageBufferDescriptorSize; - PTR32 robustStorageBufferDescriptorSize; - PTR32 inputAttachmentDescriptorSize; - PTR32 accelerationStructureDescriptorSize; - VkDeviceSize DECLSPEC_ALIGN(8) maxSamplerDescriptorBufferRange; - VkDeviceSize DECLSPEC_ALIGN(8) maxResourceDescriptorBufferRange; - VkDeviceSize DECLSPEC_ALIGN(8) samplerDescriptorBufferAddressSpaceSize; - VkDeviceSize DECLSPEC_ALIGN(8) resourceDescriptorBufferAddressSpaceSize; - VkDeviceSize DECLSPEC_ALIGN(8) descriptorBufferAddressSpaceSize; -} VkPhysicalDeviceDescriptorBufferPropertiesEXT32; + uint32_t colorAttachmentCount; + PTR32 pColorAttachmentInputIndices; + PTR32 pDepthInputAttachmentIndex; + PTR32 pStencilInputAttachmentIndex; +} VkRenderingInputAttachmentIndexInfo32; +typedef VkRenderingInputAttachmentIndexInfo32 VkRenderingInputAttachmentIndexInfoKHR32;

-typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32 +typedef struct VkResolveImageInfo232 +{ + VkStructureType sType; + PTR32 pNext; + VkImage DECLSPEC_ALIGN(8) srcImage; + VkImageLayout srcImageLayout; + VkImage DECLSPEC_ALIGN(8) dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + PTR32 pRegions; +} VkResolveImageInfo232; +typedef VkResolveImageInfo232 VkResolveImageInfo2KHR32; + +typedef struct VkSamplerBlockMatchWindowCreateInfoQCOM32 +{ + VkStructureType sType; + PTR32 pNext; + VkExtent2D windowExtent; + VkBlockMatchWindowCompareModeQCOM windowCompareMode; +} VkSamplerBlockMatchWindowCreateInfoQCOM32; + +typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkComponentMapping components; + VkBool32 srgb; +} VkSamplerBorderColorComponentMappingCreateInfoEXT32; + +typedef struct VkSamplerCaptureDescriptorDataInfoEXT32 +{ + VkStructureType sType; + PTR32 pNext; + VkSampler DECLSPEC_ALIGN(8) sampler; +} VkSamplerCaptureDescriptorDataInfoEXT32; + +typedef struct VkSamplerCreateInfo32 +{ + VkStructureType sType; + PTR32 pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} VkSamplerCreateInfo32; + +typedef struct VkSamplerCubicWeightsCreateInfoQCOM32 { VkStructureType sType; PTR32 pNext; - PTR32 combinedImageSamplerDensityMapDescriptorSize; -} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32; + VkCubicFilterWeightsQCOM cubicWeights; +} VkSamplerCubicWeightsCreateInfoQCOM32;

-typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties32 +typedef struct VkSamplerCustomBorderColorCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 integerDotProduct8BitUnsignedAccelerated; - VkBool32 integerDotProduct8BitSignedAccelerated; - VkBool32 integerDotProduct8BitMixedSignednessAccelerated; - VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProduct16BitUnsignedAccelerated; - VkBool32 integerDotProduct16BitSignedAccelerated; - VkBool32 integerDotProduct16BitMixedSignednessAccelerated; - VkBool32 integerDotProduct32BitUnsignedAccelerated; - VkBool32 integerDotProduct32BitSignedAccelerated; - VkBool32 integerDotProduct32BitMixedSignednessAccelerated; - VkBool32 integerDotProduct64BitUnsignedAccelerated; - VkBool32 integerDotProduct64BitSignedAccelerated; - VkBool32 integerDotProduct64BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; -} VkPhysicalDeviceShaderIntegerDotProductProperties32; -typedef VkPhysicalDeviceShaderIntegerDotProductProperties32 VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR32; + VkClearColorValue customBorderColor; + VkFormat format; +} VkSamplerCustomBorderColorCreateInfoEXT32;

-typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32 +typedef struct VkSamplerReductionModeCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 triStripVertexOrderIndependentOfProvokingVertex; -} VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32; + VkSamplerReductionMode reductionMode; +} VkSamplerReductionModeCreateInfo32; +typedef VkSamplerReductionModeCreateInfo32 VkSamplerReductionModeCreateInfoEXT32;

-typedef struct VkPhysicalDevicePipelineBinaryPropertiesKHR32 +typedef struct VkSamplerYcbcrConversionCreateInfo32 { VkStructureType sType; PTR32 pNext; - VkBool32 pipelineBinaryInternalCache; - VkBool32 pipelineBinaryInternalCacheControl; - VkBool32 pipelineBinaryPrefersInternalCache; - VkBool32 pipelineBinaryPrecompiledInternalCache; - VkBool32 pipelineBinaryCompressedData; -} VkPhysicalDevicePipelineBinaryPropertiesKHR32; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} VkSamplerYcbcrConversionCreateInfo32; +typedef VkSamplerYcbcrConversionCreateInfo32 VkSamplerYcbcrConversionCreateInfoKHR32;

-typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 +typedef struct VkSamplerYcbcrConversionImageFormatProperties32 { VkStructureType sType; PTR32 pNext; - VkBool32 graphicsPipelineLibraryFastLinking; - VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration; -} VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32; + uint32_t combinedImageSamplerDescriptorCount; +} VkSamplerYcbcrConversionImageFormatProperties32; +typedef VkSamplerYcbcrConversionImageFormatProperties32 VkSamplerYcbcrConversionImageFormatPropertiesKHR32;

-typedef struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT32 +typedef struct VkSamplerYcbcrConversionInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t maxCommandBufferNestingLevel; -} VkPhysicalDeviceNestedCommandBufferPropertiesEXT32; + VkSamplerYcbcrConversion DECLSPEC_ALIGN(8) conversion; +} VkSamplerYcbcrConversionInfo32; +typedef VkSamplerYcbcrConversionInfo32 VkSamplerYcbcrConversionInfoKHR32;

-typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32 +typedef struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM32 { VkStructureType sType; PTR32 pNext; - uint8_t shaderModuleIdentifierAlgorithmUUID[VK_UUID_SIZE]; -} VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32; + VkBool32 enableYDegamma; + VkBool32 enableCbCrDegamma; +} VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM32;

-typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT32 +typedef struct VkSemaphoreCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t maxOpacity2StateSubdivisionLevel; - uint32_t maxOpacity4StateSubdivisionLevel; -} VkPhysicalDeviceOpacityMicromapPropertiesEXT32; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo32;

-typedef struct VkPhysicalDevicePipelineRobustnessProperties32 +typedef struct VkSemaphoreSignalInfo32 { VkStructureType sType; PTR32 pNext; - VkPipelineRobustnessBufferBehavior defaultRobustnessStorageBuffers; - VkPipelineRobustnessBufferBehavior defaultRobustnessUniformBuffers; - VkPipelineRobustnessBufferBehavior defaultRobustnessVertexInputs; - VkPipelineRobustnessImageBehavior defaultRobustnessImages; -} VkPhysicalDevicePipelineRobustnessProperties32; -typedef VkPhysicalDevicePipelineRobustnessProperties32 VkPhysicalDevicePipelineRobustnessPropertiesEXT32; + VkSemaphore DECLSPEC_ALIGN(8) semaphore; + uint64_t DECLSPEC_ALIGN(8) value; +} VkSemaphoreSignalInfo32; +typedef VkSemaphoreSignalInfo32 VkSemaphoreSignalInfoKHR32;

-typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM32 +typedef struct VkSemaphoreTypeCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t maxWeightFilterPhases; - VkExtent2D maxWeightFilterDimension; - VkExtent2D maxBlockMatchRegion; - VkExtent2D maxBoxFilterBlockSize; -} VkPhysicalDeviceImageProcessingPropertiesQCOM32; + VkSemaphoreType semaphoreType; + uint64_t DECLSPEC_ALIGN(8) initialValue; +} VkSemaphoreTypeCreateInfo32; +typedef VkSemaphoreTypeCreateInfo32 VkSemaphoreTypeCreateInfoKHR32;

-typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV32 +typedef struct VkSemaphoreWaitInfo32 { VkStructureType sType; PTR32 pNext; - VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes; - VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes; - VkBool32 hintSupported; - VkBool32 costSupported; - VkBool32 bidirectionalFlowSupported; - VkBool32 globalFlowSupported; - uint32_t minWidth; - uint32_t minHeight; - uint32_t maxWidth; - uint32_t maxHeight; - uint32_t maxNumRegionsOfInterest; -} VkPhysicalDeviceOpticalFlowPropertiesNV32; + VkSemaphoreWaitFlags flags; + uint32_t semaphoreCount; + PTR32 pSemaphores; + PTR32 pValues; +} VkSemaphoreWaitInfo32; +typedef VkSemaphoreWaitInfo32 VkSemaphoreWaitInfoKHR32;

-typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32 +typedef struct VkSetDescriptorBufferOffsetsInfoEXT32 { VkStructureType sType; PTR32 pNext; - uint64_t DECLSPEC_ALIGN(8) shaderCoreMask; - uint32_t shaderCoreCount; - uint32_t shaderWarpsPerCore; -} VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32; + VkShaderStageFlags stageFlags; + VkPipelineLayout DECLSPEC_ALIGN(8) layout; + uint32_t firstSet; + uint32_t setCount; + PTR32 pBufferIndices; + PTR32 pOffsets; +} VkSetDescriptorBufferOffsetsInfoEXT32;

-typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32 +typedef struct VkSetLatencyMarkerInfoNV32 { VkStructureType sType; PTR32 pNext; - VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint; -} VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32; + uint64_t DECLSPEC_ALIGN(8) presentID; + VkLatencyMarkerNV marker; +} VkSetLatencyMarkerInfoNV32;

-typedef struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV32 +typedef struct VkShaderCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) extendedSparseAddressSpaceSize; - VkImageUsageFlags extendedSparseImageUsageFlags; - VkBufferUsageFlags extendedSparseBufferUsageFlags; -} VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV32; + VkShaderCreateFlagsEXT flags; + VkShaderStageFlagBits stage; + VkShaderStageFlags nextStage; + VkShaderCodeTypeEXT codeType; + PTR32 codeSize; + PTR32 pCode; + PTR32 pName; + uint32_t setLayoutCount; + PTR32 pSetLayouts; + uint32_t pushConstantRangeCount; + PTR32 pPushConstantRanges; + PTR32 pSpecializationInfo; +} VkShaderCreateInfoEXT32;

-typedef struct VkPhysicalDeviceShaderCorePropertiesARM32 +typedef struct VkShaderModuleCreateInfo32 { VkStructureType sType; PTR32 pNext; - uint32_t pixelRate; - uint32_t texelRate; - uint32_t fmaRate; -} VkPhysicalDeviceShaderCorePropertiesARM32; + VkShaderModuleCreateFlags flags; + PTR32 codeSize; + PTR32 pCode; +} VkShaderModuleCreateInfo32;

-typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT32 +typedef struct VkShaderModuleIdentifierEXT32 { VkStructureType sType; PTR32 pNext; - uint8_t shaderBinaryUUID[VK_UUID_SIZE]; - uint32_t shaderBinaryVersion; -} VkPhysicalDeviceShaderObjectPropertiesEXT32; + uint32_t identifierSize; + uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]; +} VkShaderModuleIdentifierEXT32;

-typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT32 +typedef struct VkShaderModuleValidationCacheCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - VkBool32 shaderTileImageCoherentReadAccelerated; - VkBool32 shaderTileImageReadSampleFromPixelRateInvocation; - VkBool32 shaderTileImageReadFromHelperInvocation; -} VkPhysicalDeviceShaderTileImagePropertiesEXT32; + VkValidationCacheEXT DECLSPEC_ALIGN(8) validationCache; +} VkShaderModuleValidationCacheCreateInfoEXT32;

-typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR32 +typedef struct VkSparseImageFormatProperties232 { VkStructureType sType; PTR32 pNext; - VkShaderStageFlags cooperativeMatrixSupportedStages; -} VkPhysicalDeviceCooperativeMatrixPropertiesKHR32; + VkSparseImageFormatProperties properties; +} VkSparseImageFormatProperties232; +typedef VkSparseImageFormatProperties232 VkSparseImageFormatProperties2KHR32;

-typedef struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32 +typedef struct VkSparseImageMemoryRequirements232 { VkStructureType sType; PTR32 pNext; - VkBool32 queueSubmitBoundary; - VkBool32 tileBufferTransfers; -} VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32; + VkSparseImageMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements; +} VkSparseImageMemoryRequirements232; +typedef VkSparseImageMemoryRequirements232 VkSparseImageMemoryRequirements2KHR32;

-typedef struct VkPhysicalDeviceImageProcessing2PropertiesQCOM32 +typedef struct VkSubmitInfo32 { VkStructureType sType; PTR32 pNext; - VkExtent2D maxBlockMatchWindow; -} VkPhysicalDeviceImageProcessing2PropertiesQCOM32; + uint32_t waitSemaphoreCount; + PTR32 pWaitSemaphores; + PTR32 pWaitDstStageMask; + uint32_t commandBufferCount; + PTR32 pCommandBuffers; + uint32_t signalSemaphoreCount; + PTR32 pSignalSemaphores; +} VkSubmitInfo32;

-typedef struct VkPhysicalDeviceLayeredDriverPropertiesMSFT32 +typedef struct VkSubmitInfo232 { VkStructureType sType; PTR32 pNext; - VkLayeredDriverUnderlyingApiMSFT underlyingAPI; -} VkPhysicalDeviceLayeredDriverPropertiesMSFT32; + VkSubmitFlags flags; + uint32_t waitSemaphoreInfoCount; + PTR32 pWaitSemaphoreInfos; + uint32_t commandBufferInfoCount; + PTR32 pCommandBufferInfos; + uint32_t signalSemaphoreInfoCount; + PTR32 pSignalSemaphoreInfos; +} VkSubmitInfo232; +typedef VkSubmitInfo232 VkSubmitInfo2KHR32;

-typedef struct VkPhysicalDeviceSchedulingControlsPropertiesARM32 +typedef struct VkSubpassBeginInfo32 { VkStructureType sType; PTR32 pNext; - VkPhysicalDeviceSchedulingControlsFlagsARM DECLSPEC_ALIGN(8) schedulingControlsFlags; -} VkPhysicalDeviceSchedulingControlsPropertiesARM32; + VkSubpassContents contents; +} VkSubpassBeginInfo32; +typedef VkSubpassBeginInfo32 VkSubpassBeginInfoKHR32;

-typedef struct VkPhysicalDeviceRenderPassStripedPropertiesARM32 +typedef struct VkSubpassDescriptionDepthStencilResolve32 { VkStructureType sType; PTR32 pNext; - VkExtent2D renderPassStripeGranularity; - uint32_t maxRenderPassStripes; -} VkPhysicalDeviceRenderPassStripedPropertiesARM32; + VkResolveModeFlagBits depthResolveMode; + VkResolveModeFlagBits stencilResolveMode; + PTR32 pDepthStencilResolveAttachment; +} VkSubpassDescriptionDepthStencilResolve32; +typedef VkSubpassDescriptionDepthStencilResolve32 VkSubpassDescriptionDepthStencilResolveKHR32;

-typedef struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32 +typedef struct VkSubpassEndInfo32 { VkStructureType sType; PTR32 pNext; - VkDeviceSize DECLSPEC_ALIGN(8) minPlacedMemoryMapAlignment; -} VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32; +} VkSubpassEndInfo32; +typedef VkSubpassEndInfo32 VkSubpassEndInfoKHR32;

-typedef struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA32 +typedef struct VkSubpassResolvePerformanceQueryEXT32 { VkStructureType sType; PTR32 pNext; - uint32_t supportedImageAlignmentMask; -} VkPhysicalDeviceImageAlignmentControlPropertiesMESA32; + VkBool32 optimal; +} VkSubpassResolvePerformanceQueryEXT32;

-typedef struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV32 +typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI32 { VkStructureType sType; PTR32 pNext; - uint32_t cooperativeMatrixWorkgroupScopeMaxWorkgroupSize; - uint32_t cooperativeMatrixFlexibleDimensionsMaxDimension; - uint32_t cooperativeMatrixWorkgroupScopeReservedSharedMemory; -} VkPhysicalDeviceCooperativeMatrix2PropertiesNV32; + VkRenderPass DECLSPEC_ALIGN(8) renderPass; + uint32_t subpass; +} VkSubpassShadingPipelineCreateInfoHUAWEI32;

-typedef struct VkPhysicalDeviceCooperativeVectorPropertiesNV32 +typedef struct VkSubresourceHostMemcpySize32 { VkStructureType sType; PTR32 pNext; - VkShaderStageFlags cooperativeVectorSupportedStages; - VkBool32 cooperativeVectorTrainingFloat16Accumulation; - VkBool32 cooperativeVectorTrainingFloat32Accumulation; - uint32_t maxCooperativeVectorComponents; -} VkPhysicalDeviceCooperativeVectorPropertiesNV32; + VkDeviceSize DECLSPEC_ALIGN(8) size; +} VkSubresourceHostMemcpySize32; +typedef VkSubresourceHostMemcpySize32 VkSubresourceHostMemcpySizeEXT32;

-typedef struct VkPhysicalDeviceTileShadingPropertiesQCOM32 +typedef struct VkSubresourceLayout232 { VkStructureType sType; PTR32 pNext; - uint32_t maxApronSize; - VkBool32 preferNonCoherent; - VkExtent2D tileGranularity; - VkExtent2D maxTileShadingRate; -} VkPhysicalDeviceTileShadingPropertiesQCOM32; + VkSubresourceLayout32 DECLSPEC_ALIGN(8) subresourceLayout; +} VkSubresourceLayout232; +typedef VkSubresourceLayout232 VkSubresourceLayout2KHR32; +typedef VkSubresourceLayout232 VkSubresourceLayout2EXT32;

-typedef struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32 +typedef struct VkSurfaceCapabilities2KHR32 { VkStructureType sType; PTR32 pNext; - uint32_t maxFragmentDensityMapLayers; -} VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32; + VkSurfaceCapabilitiesKHR surfaceCapabilities; +} VkSurfaceCapabilities2KHR32;

-typedef struct VkPhysicalDeviceTensorPropertiesARM32 +typedef struct VkSurfaceCapabilitiesPresentBarrierNV32 { VkStructureType sType; PTR32 pNext; - uint32_t maxTensorDimensionCount; - uint64_t DECLSPEC_ALIGN(8) maxTensorElements; - uint64_t DECLSPEC_ALIGN(8) maxPerDimensionTensorElements; - int64_t maxTensorStride; - uint64_t DECLSPEC_ALIGN(8) maxTensorSize; - uint32_t maxTensorShaderAccessArrayLength; - uint32_t maxTensorShaderAccessSize; - uint32_t maxDescriptorSetStorageTensors; - uint32_t maxPerStageDescriptorSetStorageTensors; - uint32_t maxDescriptorSetUpdateAfterBindStorageTensors; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageTensors; - VkBool32 shaderStorageTensorArrayNonUniformIndexingNative; - VkShaderStageFlags shaderTensorSupportedStages; -} VkPhysicalDeviceTensorPropertiesARM32; + VkBool32 presentBarrierSupported; +} VkSurfaceCapabilitiesPresentBarrierNV32;

-typedef struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 +typedef struct VkSurfaceCapabilitiesPresentId2KHR32 { VkStructureType sType; PTR32 pNext; - PTR32 tensorCaptureReplayDescriptorDataSize; - PTR32 tensorViewCaptureReplayDescriptorDataSize; - PTR32 tensorDescriptorSize; -} VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32; + VkBool32 presentId2Supported; +} VkSurfaceCapabilitiesPresentId2KHR32;

-typedef struct VkPhysicalDeviceProperties232 +typedef struct VkSurfaceCapabilitiesPresentWait2KHR32 { VkStructureType sType; PTR32 pNext; - VkPhysicalDeviceProperties32 DECLSPEC_ALIGN(8) properties; -} VkPhysicalDeviceProperties232; -typedef VkPhysicalDeviceProperties232 VkPhysicalDeviceProperties2KHR32; + VkBool32 presentWait2Supported; +} VkSurfaceCapabilitiesPresentWait2KHR32;

-typedef struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32 +typedef struct VkSurfaceFormat2KHR32 { VkStructureType sType; PTR32 pNext; - uint32_t queueFamilyIndex; - VkPhysicalDeviceDataGraphProcessingEngineTypeARM engineType; -} VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32; + VkSurfaceFormatKHR surfaceFormat; +} VkSurfaceFormat2KHR32;

-typedef struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 +typedef struct VkSurfacePresentModeCompatibilityKHR32 { VkStructureType sType; PTR32 pNext; - VkExternalSemaphoreHandleTypeFlags foreignSemaphoreHandleTypes; - VkExternalMemoryHandleTypeFlags foreignMemoryHandleTypes; -} VkQueueFamilyDataGraphProcessingEnginePropertiesARM32; + uint32_t presentModeCount; + PTR32 pPresentModes; +} VkSurfacePresentModeCompatibilityKHR32; +typedef VkSurfacePresentModeCompatibilityKHR32 VkSurfacePresentModeCompatibilityEXT32;

-typedef struct VkQueueFamilyDataGraphPropertiesARM32 +typedef struct VkSurfacePresentModeKHR32 { VkStructureType sType; PTR32 pNext; - VkPhysicalDeviceDataGraphProcessingEngineARM engine; - VkPhysicalDeviceDataGraphOperationSupportARM operation; -} VkQueueFamilyDataGraphPropertiesARM32; + VkPresentModeKHR presentMode; +} VkSurfacePresentModeKHR32; +typedef VkSurfacePresentModeKHR32 VkSurfacePresentModeEXT32;

-typedef struct VkQueueFamilyOwnershipTransferPropertiesKHR32 +typedef struct VkSurfacePresentScalingCapabilitiesKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t optimalImageTransferToQueueFamilies; -} VkQueueFamilyOwnershipTransferPropertiesKHR32; + VkPresentScalingFlagsKHR supportedPresentScaling; + VkPresentGravityFlagsKHR supportedPresentGravityX; + VkPresentGravityFlagsKHR supportedPresentGravityY; + VkExtent2D minScaledImageExtent; + VkExtent2D maxScaledImageExtent; +} VkSurfacePresentScalingCapabilitiesKHR32; +typedef VkSurfacePresentScalingCapabilitiesKHR32 VkSurfacePresentScalingCapabilitiesEXT32;

-typedef struct VkQueueFamilyGlobalPriorityProperties32 +typedef struct VkSwapchainCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t priorityCount; - VkQueueGlobalPriority priorities[VK_MAX_GLOBAL_PRIORITY_SIZE]; -} VkQueueFamilyGlobalPriorityProperties32; -typedef VkQueueFamilyGlobalPriorityProperties32 VkQueueFamilyGlobalPriorityPropertiesKHR32; -typedef VkQueueFamilyGlobalPriorityProperties32 VkQueueFamilyGlobalPriorityPropertiesEXT32; + VkSwapchainCreateFlagsKHR flags; + VkSurfaceKHR DECLSPEC_ALIGN(8) surface; + uint32_t minImageCount; + VkFormat imageFormat; + VkColorSpaceKHR imageColorSpace; + VkExtent2D imageExtent; + uint32_t imageArrayLayers; + VkImageUsageFlags imageUsage; + VkSharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + PTR32 pQueueFamilyIndices; + VkSurfaceTransformFlagBitsKHR preTransform; + VkCompositeAlphaFlagBitsKHR compositeAlpha; + VkPresentModeKHR presentMode; + VkBool32 clipped; + VkSwapchainKHR DECLSPEC_ALIGN(8) oldSwapchain; +} VkSwapchainCreateInfoKHR32;

-typedef struct VkQueueFamilyCheckpointPropertiesNV32 +typedef struct VkSwapchainLatencyCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkPipelineStageFlags checkpointExecutionStageMask; -} VkQueueFamilyCheckpointPropertiesNV32; + VkBool32 latencyModeEnable; +} VkSwapchainLatencyCreateInfoNV32;

-typedef struct VkQueueFamilyCheckpointProperties2NV32 +typedef struct VkSwapchainPresentBarrierCreateInfoNV32 { VkStructureType sType; PTR32 pNext; - VkPipelineStageFlags2 DECLSPEC_ALIGN(8) checkpointExecutionStageMask; -} VkQueueFamilyCheckpointProperties2NV32; + VkBool32 presentBarrierEnable; +} VkSwapchainPresentBarrierCreateInfoNV32;

-typedef struct VkQueueFamilyVideoPropertiesKHR32 +typedef struct VkSwapchainPresentFenceInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoCodecOperationFlagsKHR videoCodecOperations; -} VkQueueFamilyVideoPropertiesKHR32; + uint32_t swapchainCount; + PTR32 pFences; +} VkSwapchainPresentFenceInfoKHR32; +typedef VkSwapchainPresentFenceInfoKHR32 VkSwapchainPresentFenceInfoEXT32;

-typedef struct VkQueueFamilyQueryResultStatusPropertiesKHR32 +typedef struct VkSwapchainPresentModeInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 queryResultStatusSupport; -} VkQueueFamilyQueryResultStatusPropertiesKHR32; + uint32_t swapchainCount; + PTR32 pPresentModes; +} VkSwapchainPresentModeInfoKHR32; +typedef VkSwapchainPresentModeInfoKHR32 VkSwapchainPresentModeInfoEXT32;

-typedef struct VkQueueFamilyProperties232 +typedef struct VkSwapchainPresentModesCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkQueueFamilyProperties queueFamilyProperties; -} VkQueueFamilyProperties232; -typedef VkQueueFamilyProperties232 VkQueueFamilyProperties2KHR32; + uint32_t presentModeCount; + PTR32 pPresentModes; +} VkSwapchainPresentModesCreateInfoKHR32; +typedef VkSwapchainPresentModesCreateInfoKHR32 VkSwapchainPresentModesCreateInfoEXT32;

-typedef struct VkPhysicalDeviceSparseImageFormatInfo232 +typedef struct VkSwapchainPresentScalingCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkFormat format; - VkImageType type; - VkSampleCountFlagBits samples; - VkImageUsageFlags usage; - VkImageTiling tiling; -} VkPhysicalDeviceSparseImageFormatInfo232; -typedef VkPhysicalDeviceSparseImageFormatInfo232 VkPhysicalDeviceSparseImageFormatInfo2KHR32; + VkPresentScalingFlagsKHR scalingBehavior; + VkPresentGravityFlagsKHR presentGravityX; + VkPresentGravityFlagsKHR presentGravityY; +} VkSwapchainPresentScalingCreateInfoKHR32; +typedef VkSwapchainPresentScalingCreateInfoKHR32 VkSwapchainPresentScalingCreateInfoEXT32;

-typedef struct VkSparseImageFormatProperties232 +typedef struct VkTensorCaptureDescriptorDataInfoARM32 { VkStructureType sType; PTR32 pNext; - VkSparseImageFormatProperties properties; -} VkSparseImageFormatProperties232; -typedef VkSparseImageFormatProperties232 VkSparseImageFormatProperties2KHR32; + VkTensorARM DECLSPEC_ALIGN(8) tensor; +} VkTensorCaptureDescriptorDataInfoARM32;

-typedef struct VkFramebufferMixedSamplesCombinationNV32 +typedef struct VkTensorDependencyInfoARM32 { VkStructureType sType; PTR32 pNext; - VkCoverageReductionModeNV coverageReductionMode; - VkSampleCountFlagBits rasterizationSamples; - VkSampleCountFlags depthStencilSamples; - VkSampleCountFlags colorSamples; -} VkFramebufferMixedSamplesCombinationNV32; + uint32_t tensorMemoryBarrierCount; + PTR32 pTensorMemoryBarriers; +} VkTensorDependencyInfoARM32;

-typedef struct VkSurfacePresentModeKHR32 +typedef struct VkTensorFormatPropertiesARM32 { VkStructureType sType; PTR32 pNext; - VkPresentModeKHR presentMode; -} VkSurfacePresentModeKHR32; -typedef VkSurfacePresentModeKHR32 VkSurfacePresentModeEXT32; + VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) optimalTilingTensorFeatures; + VkFormatFeatureFlags2 DECLSPEC_ALIGN(8) linearTilingTensorFeatures; +} VkTensorFormatPropertiesARM32;

-typedef struct VkPhysicalDeviceSurfaceInfo2KHR32 +typedef struct VkTensorMemoryRequirementsInfoARM32 { VkStructureType sType; PTR32 pNext; - VkSurfaceKHR DECLSPEC_ALIGN(8) surface; -} VkPhysicalDeviceSurfaceInfo2KHR32; + VkTensorARM DECLSPEC_ALIGN(8) tensor; +} VkTensorMemoryRequirementsInfoARM32;

-typedef struct VkSurfaceCapabilitiesPresentBarrierNV32 +typedef struct VkTensorViewCaptureDescriptorDataInfoARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 presentBarrierSupported; -} VkSurfaceCapabilitiesPresentBarrierNV32; + VkTensorViewARM DECLSPEC_ALIGN(8) tensorView; +} VkTensorViewCaptureDescriptorDataInfoARM32;

-typedef struct VkSurfaceCapabilitiesPresentId2KHR32 +typedef struct VkTensorViewCreateInfoARM32 { VkStructureType sType; PTR32 pNext; - VkBool32 presentId2Supported; -} VkSurfaceCapabilitiesPresentId2KHR32; + VkTensorViewCreateFlagsARM DECLSPEC_ALIGN(8) flags; + VkTensorARM DECLSPEC_ALIGN(8) tensor; + VkFormat format; +} VkTensorViewCreateInfoARM32;

-typedef struct VkSurfaceCapabilitiesPresentWait2KHR32 +typedef struct VkTextureLODGatherFormatPropertiesAMD32 { VkStructureType sType; PTR32 pNext; - VkBool32 presentWait2Supported; -} VkSurfaceCapabilitiesPresentWait2KHR32; + VkBool32 supportsTextureGatherLODBiasAMD; +} VkTextureLODGatherFormatPropertiesAMD32;

-typedef struct VkSurfacePresentScalingCapabilitiesKHR32 +typedef struct VkTileMemoryBindInfoQCOM32 { VkStructureType sType; PTR32 pNext; - VkPresentScalingFlagsKHR supportedPresentScaling; - VkPresentGravityFlagsKHR supportedPresentGravityX; - VkPresentGravityFlagsKHR supportedPresentGravityY; - VkExtent2D minScaledImageExtent; - VkExtent2D maxScaledImageExtent; -} VkSurfacePresentScalingCapabilitiesKHR32; -typedef VkSurfacePresentScalingCapabilitiesKHR32 VkSurfacePresentScalingCapabilitiesEXT32; + VkDeviceMemory DECLSPEC_ALIGN(8) memory; +} VkTileMemoryBindInfoQCOM32;

-typedef struct VkSurfacePresentModeCompatibilityKHR32 +typedef struct VkTileMemoryRequirementsQCOM32 { VkStructureType sType; PTR32 pNext; - uint32_t presentModeCount; - PTR32 pPresentModes; -} VkSurfacePresentModeCompatibilityKHR32; -typedef VkSurfacePresentModeCompatibilityKHR32 VkSurfacePresentModeCompatibilityEXT32; + VkDeviceSize DECLSPEC_ALIGN(8) size; + VkDeviceSize DECLSPEC_ALIGN(8) alignment; +} VkTileMemoryRequirementsQCOM32;

-typedef struct VkLatencySurfaceCapabilitiesNV32 +typedef struct VkTileMemorySizeInfoQCOM32 { VkStructureType sType; PTR32 pNext; - uint32_t presentModeCount; - PTR32 pPresentModes; -} VkLatencySurfaceCapabilitiesNV32; + VkDeviceSize DECLSPEC_ALIGN(8) size; +} VkTileMemorySizeInfoQCOM32;

-typedef struct VkSurfaceCapabilities2KHR32 +typedef struct VkTilePropertiesQCOM32 { VkStructureType sType; PTR32 pNext; - VkSurfaceCapabilitiesKHR surfaceCapabilities; -} VkSurfaceCapabilities2KHR32; + VkExtent3D tileSize; + VkExtent2D apronSize; + VkOffset2D origin; +} VkTilePropertiesQCOM32;

-typedef struct VkSurfaceFormat2KHR32 +typedef struct VkTimelineSemaphoreSubmitInfo32 { VkStructureType sType; PTR32 pNext; - VkSurfaceFormatKHR surfaceFormat; -} VkSurfaceFormat2KHR32; + uint32_t waitSemaphoreValueCount; + PTR32 pWaitSemaphoreValues; + uint32_t signalSemaphoreValueCount; + PTR32 pSignalSemaphoreValues; +} VkTimelineSemaphoreSubmitInfo32; +typedef VkTimelineSemaphoreSubmitInfo32 VkTimelineSemaphoreSubmitInfoKHR32;

-typedef struct VkPhysicalDeviceToolProperties32 +typedef struct VkValidationCacheCreateInfoEXT32 { VkStructureType sType; PTR32 pNext; - char name[VK_MAX_EXTENSION_NAME_SIZE]; - char version[VK_MAX_EXTENSION_NAME_SIZE]; - VkToolPurposeFlags purposes; - char description[VK_MAX_DESCRIPTION_SIZE]; - char layer[VK_MAX_EXTENSION_NAME_SIZE]; -} VkPhysicalDeviceToolProperties32; -typedef VkPhysicalDeviceToolProperties32 VkPhysicalDeviceToolPropertiesEXT32; + VkValidationCacheCreateFlagsEXT flags; + PTR32 initialDataSize; + PTR32 pInitialData; +} VkValidationCacheCreateInfoEXT32;

-typedef struct VkVideoEncodeQuantizationMapCapabilitiesKHR32 +typedef struct VkValidationFeaturesEXT32 { VkStructureType sType; PTR32 pNext; - VkExtent2D maxQuantizationMapExtent; -} VkVideoEncodeQuantizationMapCapabilitiesKHR32; + uint32_t enabledValidationFeatureCount; + PTR32 pEnabledValidationFeatures; + uint32_t disabledValidationFeatureCount; + PTR32 pDisabledValidationFeatures; +} VkValidationFeaturesEXT32;

-typedef struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR32 +typedef struct VkValidationFlagsEXT32 { VkStructureType sType; PTR32 pNext; - int32_t minQpDelta; - int32_t maxQpDelta; -} VkVideoEncodeH264QuantizationMapCapabilitiesKHR32; + uint32_t disabledValidationCheckCount; + PTR32 pDisabledValidationChecks; +} VkValidationFlagsEXT32;

-typedef struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR32 +typedef struct VkVertexInputAttributeDescription2EXT32 { VkStructureType sType; PTR32 pNext; - int32_t minQpDelta; - int32_t maxQpDelta; -} VkVideoEncodeH265QuantizationMapCapabilitiesKHR32; + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription2EXT32;

-typedef struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32 +typedef struct VkVertexInputBindingDescription2EXT32 { VkStructureType sType; PTR32 pNext; - int32_t minQIndexDelta; - int32_t maxQIndexDelta; -} VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32; + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; + uint32_t divisor; +} VkVertexInputBindingDescription2EXT32;

-typedef struct VkVideoDecodeCapabilitiesKHR32 +typedef struct VkVideoBeginCodingInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoDecodeCapabilityFlagsKHR flags; -} VkVideoDecodeCapabilitiesKHR32; + VkVideoBeginCodingFlagsKHR flags; + VkVideoSessionKHR DECLSPEC_ALIGN(8) videoSession; + VkVideoSessionParametersKHR DECLSPEC_ALIGN(8) videoSessionParameters; + uint32_t referenceSlotCount; + PTR32 pReferenceSlots; +} VkVideoBeginCodingInfoKHR32;

-typedef struct VkVideoDecodeH264CapabilitiesKHR32 +typedef struct VkVideoCapabilitiesKHR32 { VkStructureType sType; PTR32 pNext; - StdVideoH264LevelIdc maxLevelIdc; - VkOffset2D fieldOffsetGranularity; -} VkVideoDecodeH264CapabilitiesKHR32; + VkVideoCapabilityFlagsKHR flags; + VkDeviceSize DECLSPEC_ALIGN(8) minBitstreamBufferOffsetAlignment; + VkDeviceSize DECLSPEC_ALIGN(8) minBitstreamBufferSizeAlignment; + VkExtent2D pictureAccessGranularity; + VkExtent2D minCodedExtent; + VkExtent2D maxCodedExtent; + uint32_t maxDpbSlots; + uint32_t maxActiveReferencePictures; + VkExtensionProperties stdHeaderVersion; +} VkVideoCapabilitiesKHR32;

-typedef struct VkVideoDecodeVP9CapabilitiesKHR32 +typedef struct VkVideoCodingControlInfoKHR32 { VkStructureType sType; PTR32 pNext; - StdVideoVP9Level maxLevel; -} VkVideoDecodeVP9CapabilitiesKHR32; + VkVideoCodingControlFlagsKHR flags; +} VkVideoCodingControlInfoKHR32;

typedef struct VkVideoDecodeAV1CapabilitiesKHR32 { @@ -8726,760 +8821,691 @@ typedef struct VkVideoDecodeAV1CapabilitiesKHR32 StdVideoAV1Level maxLevel; } VkVideoDecodeAV1CapabilitiesKHR32;

-typedef struct VkVideoEncodeCapabilitiesKHR32 +typedef struct VkVideoDecodeAV1DpbSlotInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeCapabilityFlagsKHR flags; - VkVideoEncodeRateControlModeFlagsKHR rateControlModes; - uint32_t maxRateControlLayers; - uint64_t DECLSPEC_ALIGN(8) maxBitrate; - uint32_t maxQualityLevels; - VkExtent2D encodeInputPictureGranularity; - VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags; -} VkVideoEncodeCapabilitiesKHR32; + PTR32 pStdReferenceInfo; +} VkVideoDecodeAV1DpbSlotInfoKHR32;

-typedef struct VkVideoEncodeH264CapabilitiesKHR32 +typedef struct VkVideoDecodeAV1PictureInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeH264CapabilityFlagsKHR flags; - StdVideoH264LevelIdc maxLevelIdc; - uint32_t maxSliceCount; - uint32_t maxPPictureL0ReferenceCount; - uint32_t maxBPictureL0ReferenceCount; - uint32_t maxL1ReferenceCount; - uint32_t maxTemporalLayerCount; - VkBool32 expectDyadicTemporalLayerPattern; - int32_t minQp; - int32_t maxQp; - VkBool32 prefersGopRemainingFrames; - VkBool32 requiresGopRemainingFrames; - VkVideoEncodeH264StdFlagsKHR stdSyntaxFlags; -} VkVideoEncodeH264CapabilitiesKHR32; + PTR32 pStdPictureInfo; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; + uint32_t frameHeaderOffset; + uint32_t tileCount; + PTR32 pTileOffsets; + PTR32 pTileSizes; +} VkVideoDecodeAV1PictureInfoKHR32;

-typedef struct VkVideoEncodeAV1CapabilitiesKHR32 +typedef struct VkVideoDecodeAV1ProfileInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeAV1CapabilityFlagsKHR flags; - StdVideoAV1Level maxLevel; - VkExtent2D codedPictureAlignment; - VkExtent2D maxTiles; - VkExtent2D minTileSize; - VkExtent2D maxTileSize; - VkVideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes; - uint32_t maxSingleReferenceCount; - uint32_t singleReferenceNameMask; - uint32_t maxUnidirectionalCompoundReferenceCount; - uint32_t maxUnidirectionalCompoundGroup1ReferenceCount; - uint32_t unidirectionalCompoundReferenceNameMask; - uint32_t maxBidirectionalCompoundReferenceCount; - uint32_t maxBidirectionalCompoundGroup1ReferenceCount; - uint32_t maxBidirectionalCompoundGroup2ReferenceCount; - uint32_t bidirectionalCompoundReferenceNameMask; - uint32_t maxTemporalLayerCount; - uint32_t maxSpatialLayerCount; - uint32_t maxOperatingPoints; - uint32_t minQIndex; - uint32_t maxQIndex; - VkBool32 prefersGopRemainingFrames; - VkBool32 requiresGopRemainingFrames; - VkVideoEncodeAV1StdFlagsKHR stdSyntaxFlags; -} VkVideoEncodeAV1CapabilitiesKHR32; + StdVideoAV1Profile stdProfile; + VkBool32 filmGrainSupport; +} VkVideoDecodeAV1ProfileInfoKHR32;

-typedef struct VkVideoEncodeIntraRefreshCapabilitiesKHR32 +typedef struct VkVideoDecodeAV1SessionParametersCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes; - uint32_t maxIntraRefreshCycleDuration; - uint32_t maxIntraRefreshActiveReferencePictures; - VkBool32 partitionIndependentIntraRefreshRegions; - VkBool32 nonRectangularIntraRefreshRegions; -} VkVideoEncodeIntraRefreshCapabilitiesKHR32; + PTR32 pStdSequenceHeader; +} VkVideoDecodeAV1SessionParametersCreateInfoKHR32;

-typedef struct VkVideoCapabilitiesKHR32 +typedef struct VkVideoDecodeCapabilitiesKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoCapabilityFlagsKHR flags; - VkDeviceSize DECLSPEC_ALIGN(8) minBitstreamBufferOffsetAlignment; - VkDeviceSize DECLSPEC_ALIGN(8) minBitstreamBufferSizeAlignment; - VkExtent2D pictureAccessGranularity; - VkExtent2D minCodedExtent; - VkExtent2D maxCodedExtent; - uint32_t maxDpbSlots; - uint32_t maxActiveReferencePictures; - VkExtensionProperties stdHeaderVersion; -} VkVideoCapabilitiesKHR32; + VkVideoDecodeCapabilityFlagsKHR flags; +} VkVideoDecodeCapabilitiesKHR32;

-typedef struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR32 +typedef struct VkVideoDecodeH264CapabilitiesKHR32 { VkStructureType sType; PTR32 pNext; - PTR32 pVideoProfile; - uint32_t qualityLevel; -} VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR32; + StdVideoH264LevelIdc maxLevelIdc; + VkOffset2D fieldOffsetGranularity; +} VkVideoDecodeH264CapabilitiesKHR32;

-typedef struct VkVideoEncodeH264QualityLevelPropertiesKHR32 +typedef struct VkVideoDecodeH264DpbSlotInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeH264RateControlFlagsKHR preferredRateControlFlags; - uint32_t preferredGopFrameCount; - uint32_t preferredIdrPeriod; - uint32_t preferredConsecutiveBFrameCount; - uint32_t preferredTemporalLayerCount; - VkVideoEncodeH264QpKHR preferredConstantQp; - uint32_t preferredMaxL0ReferenceCount; - uint32_t preferredMaxL1ReferenceCount; - VkBool32 preferredStdEntropyCodingModeFlag; -} VkVideoEncodeH264QualityLevelPropertiesKHR32; + PTR32 pStdReferenceInfo; +} VkVideoDecodeH264DpbSlotInfoKHR32;

-typedef struct VkVideoEncodeAV1QualityLevelPropertiesKHR32 +typedef struct VkVideoDecodeH264PictureInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags; - uint32_t preferredGopFrameCount; - uint32_t preferredKeyFramePeriod; - uint32_t preferredConsecutiveBipredictiveFrameCount; - uint32_t preferredTemporalLayerCount; - VkVideoEncodeAV1QIndexKHR preferredConstantQIndex; - uint32_t preferredMaxSingleReferenceCount; - uint32_t preferredSingleReferenceNameMask; - uint32_t preferredMaxUnidirectionalCompoundReferenceCount; - uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount; - uint32_t preferredUnidirectionalCompoundReferenceNameMask; - uint32_t preferredMaxBidirectionalCompoundReferenceCount; - uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount; - uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount; - uint32_t preferredBidirectionalCompoundReferenceNameMask; -} VkVideoEncodeAV1QualityLevelPropertiesKHR32; + PTR32 pStdPictureInfo; + uint32_t sliceCount; + PTR32 pSliceOffsets; +} VkVideoDecodeH264PictureInfoKHR32; + +typedef struct VkVideoDecodeH264ProfileInfoKHR32 +{ + VkStructureType sType; + PTR32 pNext; + StdVideoH264ProfileIdc stdProfileIdc; + VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout; +} VkVideoDecodeH264ProfileInfoKHR32;

-typedef struct VkVideoEncodeQualityLevelPropertiesKHR32 +typedef struct VkVideoDecodeH264SessionParametersCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode; - uint32_t preferredRateControlLayerCount; -} VkVideoEncodeQualityLevelPropertiesKHR32; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + PTR32 pParametersAddInfo; +} VkVideoDecodeH264SessionParametersCreateInfoKHR32;

-typedef struct VkPhysicalDeviceVideoFormatInfoKHR32 +typedef struct VkVideoDecodeInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkImageUsageFlags imageUsage; -} VkPhysicalDeviceVideoFormatInfoKHR32; + VkVideoDecodeFlagsKHR flags; + VkBuffer DECLSPEC_ALIGN(8) srcBuffer; + VkDeviceSize DECLSPEC_ALIGN(8) srcBufferOffset; + VkDeviceSize DECLSPEC_ALIGN(8) srcBufferRange; + VkVideoPictureResourceInfoKHR32 DECLSPEC_ALIGN(8) dstPictureResource; + PTR32 pSetupReferenceSlot; + uint32_t referenceSlotCount; + PTR32 pReferenceSlots; +} VkVideoDecodeInfoKHR32;

-typedef struct VkVideoFormatQuantizationMapPropertiesKHR32 +typedef struct VkVideoDecodeUsageInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkExtent2D quantizationMapTexelSize; -} VkVideoFormatQuantizationMapPropertiesKHR32; + VkVideoDecodeUsageFlagsKHR videoUsageHints; +} VkVideoDecodeUsageInfoKHR32;

-typedef struct VkVideoFormatH265QuantizationMapPropertiesKHR32 +typedef struct VkVideoDecodeVP9CapabilitiesKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes; -} VkVideoFormatH265QuantizationMapPropertiesKHR32; + StdVideoVP9Level maxLevel; +} VkVideoDecodeVP9CapabilitiesKHR32;

-typedef struct VkVideoFormatAV1QuantizationMapPropertiesKHR32 +typedef struct VkVideoDecodeVP9PictureInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkVideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes; -} VkVideoFormatAV1QuantizationMapPropertiesKHR32; + PTR32 pStdPictureInfo; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR]; + uint32_t uncompressedHeaderOffset; + uint32_t compressedHeaderOffset; + uint32_t tilesOffset; +} VkVideoDecodeVP9PictureInfoKHR32;

-typedef struct VkVideoFormatPropertiesKHR32 +typedef struct VkVideoDecodeVP9ProfileInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkFormat format; - VkComponentMapping componentMapping; - VkImageCreateFlags imageCreateFlags; - VkImageType imageType; - VkImageTiling imageTiling; - VkImageUsageFlags imageUsageFlags; -} VkVideoFormatPropertiesKHR32; + StdVideoVP9Profile stdProfile; +} VkVideoDecodeVP9ProfileInfoKHR32;

-typedef struct VkPipelineBinaryDataInfoKHR32 +typedef struct VkVideoEncodeAV1CapabilitiesKHR32 { VkStructureType sType; PTR32 pNext; - VkPipelineBinaryKHR DECLSPEC_ALIGN(8) pipelineBinary; -} VkPipelineBinaryDataInfoKHR32; + VkVideoEncodeAV1CapabilityFlagsKHR flags; + StdVideoAV1Level maxLevel; + VkExtent2D codedPictureAlignment; + VkExtent2D maxTiles; + VkExtent2D minTileSize; + VkExtent2D maxTileSize; + VkVideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes; + uint32_t maxSingleReferenceCount; + uint32_t singleReferenceNameMask; + uint32_t maxUnidirectionalCompoundReferenceCount; + uint32_t maxUnidirectionalCompoundGroup1ReferenceCount; + uint32_t unidirectionalCompoundReferenceNameMask; + uint32_t maxBidirectionalCompoundReferenceCount; + uint32_t maxBidirectionalCompoundGroup1ReferenceCount; + uint32_t maxBidirectionalCompoundGroup2ReferenceCount; + uint32_t bidirectionalCompoundReferenceNameMask; + uint32_t maxTemporalLayerCount; + uint32_t maxSpatialLayerCount; + uint32_t maxOperatingPoints; + uint32_t minQIndex; + uint32_t maxQIndex; + VkBool32 prefersGopRemainingFrames; + VkBool32 requiresGopRemainingFrames; + VkVideoEncodeAV1StdFlagsKHR stdSyntaxFlags; +} VkVideoEncodeAV1CapabilitiesKHR32;

-typedef struct VkPipelineExecutableInfoKHR32 +typedef struct VkVideoEncodeAV1DpbSlotInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkPipeline DECLSPEC_ALIGN(8) pipeline; - uint32_t executableIndex; -} VkPipelineExecutableInfoKHR32; + PTR32 pStdReferenceInfo; +} VkVideoEncodeAV1DpbSlotInfoKHR32;

-typedef struct VkPipelineExecutableInternalRepresentationKHR32 +typedef struct VkVideoEncodeAV1GopRemainingFrameInfoKHR32 { VkStructureType sType; PTR32 pNext; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - VkBool32 isText; - PTR32 dataSize; - PTR32 pData; -} VkPipelineExecutableInternalRepresentationKHR32; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingIntra; + uint32_t gopRemainingPredictive; + uint32_t gopRemainingBipredictive; +} VkVideoEncodeAV1GopRemainingFrameInfoKHR32;

-typedef struct VkPipelineInfoKHR32 +typedef struct VkVideoEncodeAV1PictureInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkPipeline DECLSPEC_ALIGN(8) pipeline; -} VkPipelineInfoKHR32; -typedef VkPipelineInfoKHR32 VkPipelineInfoEXT32; + VkVideoEncodeAV1PredictionModeKHR predictionMode; + VkVideoEncodeAV1RateControlGroupKHR rateControlGroup; + uint32_t constantQIndex; + PTR32 pStdPictureInfo; + int32_t referenceNameSlotIndices[VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR]; + VkBool32 primaryReferenceCdfOnly; + VkBool32 generateObuExtensionHeader; +} VkVideoEncodeAV1PictureInfoKHR32;

-typedef struct VkPipelineExecutablePropertiesKHR32 +typedef struct VkVideoEncodeAV1ProfileInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkShaderStageFlags stages; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - uint32_t subgroupSize; -} VkPipelineExecutablePropertiesKHR32; + StdVideoAV1Profile stdProfile; +} VkVideoEncodeAV1ProfileInfoKHR32;

-typedef union VkPipelineExecutableStatisticValueKHR32 +typedef struct VkVideoEncodeAV1QualityLevelPropertiesKHR32 { - VkBool32 b32; - int64_t i64; - uint64_t DECLSPEC_ALIGN(8) u64; - double f64; -} VkPipelineExecutableStatisticValueKHR32; + VkStructureType sType; + PTR32 pNext; + VkVideoEncodeAV1RateControlFlagsKHR preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredKeyFramePeriod; + uint32_t preferredConsecutiveBipredictiveFrameCount; + uint32_t preferredTemporalLayerCount; + VkVideoEncodeAV1QIndexKHR preferredConstantQIndex; + uint32_t preferredMaxSingleReferenceCount; + uint32_t preferredSingleReferenceNameMask; + uint32_t preferredMaxUnidirectionalCompoundReferenceCount; + uint32_t preferredMaxUnidirectionalCompoundGroup1ReferenceCount; + uint32_t preferredUnidirectionalCompoundReferenceNameMask; + uint32_t preferredMaxBidirectionalCompoundReferenceCount; + uint32_t preferredMaxBidirectionalCompoundGroup1ReferenceCount; + uint32_t preferredMaxBidirectionalCompoundGroup2ReferenceCount; + uint32_t preferredBidirectionalCompoundReferenceNameMask; +} VkVideoEncodeAV1QualityLevelPropertiesKHR32;

-typedef struct VkPipelineExecutableStatisticKHR32 +typedef struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32 { VkStructureType sType; PTR32 pNext; - char name[VK_MAX_DESCRIPTION_SIZE]; - char description[VK_MAX_DESCRIPTION_SIZE]; - VkPipelineExecutableStatisticFormatKHR format; - VkPipelineExecutableStatisticValueKHR32 DECLSPEC_ALIGN(8) value; -} VkPipelineExecutableStatisticKHR32; + int32_t minQIndexDelta; + int32_t maxQIndexDelta; +} VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32;

-typedef struct VkPipelineIndirectDeviceAddressInfoNV32 +typedef struct VkVideoEncodeAV1RateControlInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkPipelineBindPoint pipelineBindPoint; - VkPipeline DECLSPEC_ALIGN(8) pipeline; -} VkPipelineIndirectDeviceAddressInfoNV32; - + VkVideoEncodeAV1RateControlFlagsKHR flags; + uint32_t gopFrameCount; + uint32_t keyFramePeriod; + uint32_t consecutiveBipredictiveFrameCount; + uint32_t temporalLayerCount; +} VkVideoEncodeAV1RateControlInfoKHR32;

-typedef struct VkCheckpointData2NV32 +typedef struct VkVideoEncodeAV1RateControlLayerInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stage; - PTR32 pCheckpointMarker; -} VkCheckpointData2NV32; + VkBool32 useMinQIndex; + VkVideoEncodeAV1QIndexKHR minQIndex; + VkBool32 useMaxQIndex; + VkVideoEncodeAV1QIndexKHR maxQIndex; + VkBool32 useMaxFrameSize; + VkVideoEncodeAV1FrameSizeKHR maxFrameSize; +} VkVideoEncodeAV1RateControlLayerInfoKHR32;

-typedef struct VkCheckpointDataNV32 +typedef struct VkVideoEncodeAV1SessionCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkPipelineStageFlagBits stage; - PTR32 pCheckpointMarker; -} VkCheckpointDataNV32; + VkBool32 useMaxLevel; + StdVideoAV1Level maxLevel; +} VkVideoEncodeAV1SessionCreateInfoKHR32;

-typedef struct VkRenderingAreaInfo32 +typedef struct VkVideoEncodeAV1SessionParametersCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t viewMask; - uint32_t colorAttachmentCount; - PTR32 pColorAttachmentFormats; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; -} VkRenderingAreaInfo32; -typedef VkRenderingAreaInfo32 VkRenderingAreaInfoKHR32; + PTR32 pStdSequenceHeader; + PTR32 pStdDecoderModelInfo; + uint32_t stdOperatingPointCount; + PTR32 pStdOperatingPoints; +} VkVideoEncodeAV1SessionParametersCreateInfoKHR32;

-typedef struct VkSamplerCaptureDescriptorDataInfoEXT32 +typedef struct VkVideoEncodeCapabilitiesKHR32 { VkStructureType sType; PTR32 pNext; - VkSampler DECLSPEC_ALIGN(8) sampler; -} VkSamplerCaptureDescriptorDataInfoEXT32; + VkVideoEncodeCapabilityFlagsKHR flags; + VkVideoEncodeRateControlModeFlagsKHR rateControlModes; + uint32_t maxRateControlLayers; + uint64_t DECLSPEC_ALIGN(8) maxBitrate; + uint32_t maxQualityLevels; + VkExtent2D encodeInputPictureGranularity; + VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags; +} VkVideoEncodeCapabilitiesKHR32;

-typedef struct VkShaderModuleIdentifierEXT32 +typedef struct VkVideoEncodeH264CapabilitiesKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t identifierSize; - uint8_t identifier[VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT]; -} VkShaderModuleIdentifierEXT32; + VkVideoEncodeH264CapabilityFlagsKHR flags; + StdVideoH264LevelIdc maxLevelIdc; + uint32_t maxSliceCount; + uint32_t maxPPictureL0ReferenceCount; + uint32_t maxBPictureL0ReferenceCount; + uint32_t maxL1ReferenceCount; + uint32_t maxTemporalLayerCount; + VkBool32 expectDyadicTemporalLayerPattern; + int32_t minQp; + int32_t maxQp; + VkBool32 prefersGopRemainingFrames; + VkBool32 requiresGopRemainingFrames; + VkVideoEncodeH264StdFlagsKHR stdSyntaxFlags; +} VkVideoEncodeH264CapabilitiesKHR32;

-typedef struct VkTensorMemoryRequirementsInfoARM32 +typedef struct VkVideoEncodeH264DpbSlotInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkTensorARM DECLSPEC_ALIGN(8) tensor; -} VkTensorMemoryRequirementsInfoARM32; + PTR32 pStdReferenceInfo; +} VkVideoEncodeH264DpbSlotInfoKHR32;

-typedef struct VkTensorCaptureDescriptorDataInfoARM32 +typedef struct VkVideoEncodeH264GopRemainingFrameInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkTensorARM DECLSPEC_ALIGN(8) tensor; -} VkTensorCaptureDescriptorDataInfoARM32; + VkBool32 useGopRemainingFrames; + uint32_t gopRemainingI; + uint32_t gopRemainingP; + uint32_t gopRemainingB; +} VkVideoEncodeH264GopRemainingFrameInfoKHR32;

-typedef struct VkTensorViewCaptureDescriptorDataInfoARM32 +typedef struct VkVideoEncodeH264PictureInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkTensorViewARM DECLSPEC_ALIGN(8) tensorView; -} VkTensorViewCaptureDescriptorDataInfoARM32; + uint32_t naluSliceEntryCount; + PTR32 pNaluSliceEntries; + PTR32 pStdPictureInfo; + VkBool32 generatePrefixNalu; +} VkVideoEncodeH264PictureInfoKHR32;

-typedef struct VkVideoSessionMemoryRequirementsKHR32 +typedef struct VkVideoEncodeH264ProfileInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t memoryBindIndex; - VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements; -} VkVideoSessionMemoryRequirementsKHR32; + StdVideoH264ProfileIdc stdProfileIdc; +} VkVideoEncodeH264ProfileInfoKHR32;

-typedef struct VkInitializePerformanceApiInfoINTEL32 +typedef struct VkVideoEncodeH264QualityLevelPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - PTR32 pUserData; -} VkInitializePerformanceApiInfoINTEL32; + VkVideoEncodeH264RateControlFlagsKHR preferredRateControlFlags; + uint32_t preferredGopFrameCount; + uint32_t preferredIdrPeriod; + uint32_t preferredConsecutiveBFrameCount; + uint32_t preferredTemporalLayerCount; + VkVideoEncodeH264QpKHR preferredConstantQp; + uint32_t preferredMaxL0ReferenceCount; + uint32_t preferredMaxL1ReferenceCount; + VkBool32 preferredStdEntropyCodingModeFlag; +} VkVideoEncodeH264QualityLevelPropertiesKHR32;

-typedef struct VkLatencySleepInfoNV32 +typedef struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR32 { VkStructureType sType; PTR32 pNext; - VkSemaphore DECLSPEC_ALIGN(8) signalSemaphore; - uint64_t DECLSPEC_ALIGN(8) value; -} VkLatencySleepInfoNV32; + int32_t minQpDelta; + int32_t maxQpDelta; +} VkVideoEncodeH264QuantizationMapCapabilitiesKHR32;

-typedef struct VkMemoryMapPlacedInfoEXT32 +typedef struct VkVideoEncodeH264RateControlInfoKHR32 { VkStructureType sType; PTR32 pNext; - PTR32 pPlacedAddress; -} VkMemoryMapPlacedInfoEXT32; + VkVideoEncodeH264RateControlFlagsKHR flags; + uint32_t gopFrameCount; + uint32_t idrPeriod; + uint32_t consecutiveBFrameCount; + uint32_t temporalLayerCount; +} VkVideoEncodeH264RateControlInfoKHR32;

-typedef struct VkMemoryMapInfo32 +typedef struct VkVideoEncodeH264RateControlLayerInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkMemoryMapFlags flags; - VkDeviceMemory DECLSPEC_ALIGN(8) memory; - VkDeviceSize DECLSPEC_ALIGN(8) offset; - VkDeviceSize DECLSPEC_ALIGN(8) size; -} VkMemoryMapInfo32; -typedef VkMemoryMapInfo32 VkMemoryMapInfoKHR32; - -typedef struct VkSparseMemoryBind32 -{ - VkDeviceSize DECLSPEC_ALIGN(8) resourceOffset; - VkDeviceSize DECLSPEC_ALIGN(8) size; - VkDeviceMemory DECLSPEC_ALIGN(8) memory; - VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; - VkSparseMemoryBindFlags flags; -} VkSparseMemoryBind32; - -typedef struct VkSparseBufferMemoryBindInfo32 -{ - VkBuffer DECLSPEC_ALIGN(8) buffer; - uint32_t bindCount; - PTR32 pBinds; -} VkSparseBufferMemoryBindInfo32; - -typedef struct VkSparseImageOpaqueMemoryBindInfo32 -{ - VkImage DECLSPEC_ALIGN(8) image; - uint32_t bindCount; - PTR32 pBinds; -} VkSparseImageOpaqueMemoryBindInfo32; - -typedef struct VkSparseImageMemoryBind32 -{ - VkImageSubresource subresource; - VkOffset3D offset; - VkExtent3D extent; - VkDeviceMemory DECLSPEC_ALIGN(8) memory; - VkDeviceSize DECLSPEC_ALIGN(8) memoryOffset; - VkSparseMemoryBindFlags flags; -} VkSparseImageMemoryBind32; - -typedef struct VkSparseImageMemoryBindInfo32 -{ - VkImage DECLSPEC_ALIGN(8) image; - uint32_t bindCount; - PTR32 pBinds; -} VkSparseImageMemoryBindInfo32; + VkBool32 useMinQp; + VkVideoEncodeH264QpKHR minQp; + VkBool32 useMaxQp; + VkVideoEncodeH264QpKHR maxQp; + VkBool32 useMaxFrameSize; + VkVideoEncodeH264FrameSizeKHR maxFrameSize; +} VkVideoEncodeH264RateControlLayerInfoKHR32;

-typedef struct VkDeviceGroupBindSparseInfo32 +typedef struct VkVideoEncodeH264SessionCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t resourceDeviceIndex; - uint32_t memoryDeviceIndex; -} VkDeviceGroupBindSparseInfo32; -typedef VkDeviceGroupBindSparseInfo32 VkDeviceGroupBindSparseInfoKHR32; + VkBool32 useMaxLevelIdc; + StdVideoH264LevelIdc maxLevelIdc; +} VkVideoEncodeH264SessionCreateInfoKHR32;

-typedef struct VkTimelineSemaphoreSubmitInfo32 +typedef struct VkVideoEncodeH264SessionParametersCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t waitSemaphoreValueCount; - PTR32 pWaitSemaphoreValues; - uint32_t signalSemaphoreValueCount; - PTR32 pSignalSemaphoreValues; -} VkTimelineSemaphoreSubmitInfo32; -typedef VkTimelineSemaphoreSubmitInfo32 VkTimelineSemaphoreSubmitInfoKHR32; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + PTR32 pParametersAddInfo; +} VkVideoEncodeH264SessionParametersCreateInfoKHR32;

-typedef struct VkFrameBoundaryEXT32 +typedef struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkFrameBoundaryFlagsEXT flags; - uint64_t DECLSPEC_ALIGN(8) frameID; - uint32_t imageCount; - PTR32 pImages; - uint32_t bufferCount; - PTR32 pBuffers; - uint64_t DECLSPEC_ALIGN(8) tagName; - PTR32 tagSize; - PTR32 pTag; -} VkFrameBoundaryEXT32; + VkBool32 hasStdSPSOverrides; + VkBool32 hasStdPPSOverrides; +} VkVideoEncodeH264SessionParametersFeedbackInfoKHR32;

-typedef struct VkFrameBoundaryTensorsARM32 +typedef struct VkVideoEncodeH264SessionParametersGetInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t tensorCount; - PTR32 pTensors; -} VkFrameBoundaryTensorsARM32; + VkBool32 writeStdSPS; + VkBool32 writeStdPPS; + uint32_t stdSPSId; + uint32_t stdPPSId; +} VkVideoEncodeH264SessionParametersGetInfoKHR32;

-typedef struct VkBindSparseInfo32 +typedef struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t waitSemaphoreCount; - PTR32 pWaitSemaphores; - uint32_t bufferBindCount; - PTR32 pBufferBinds; - uint32_t imageOpaqueBindCount; - PTR32 pImageOpaqueBinds; - uint32_t imageBindCount; - PTR32 pImageBinds; - uint32_t signalSemaphoreCount; - PTR32 pSignalSemaphores; -} VkBindSparseInfo32; + int32_t minQpDelta; + int32_t maxQpDelta; +} VkVideoEncodeH265QuantizationMapCapabilitiesKHR32;

-typedef struct VkOutOfBandQueueTypeInfoNV32 +typedef struct VkVideoEncodeInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkOutOfBandQueueTypeNV queueType; -} VkOutOfBandQueueTypeInfoNV32; + VkVideoEncodeFlagsKHR flags; + VkBuffer DECLSPEC_ALIGN(8) dstBuffer; + VkDeviceSize DECLSPEC_ALIGN(8) dstBufferOffset; + VkDeviceSize DECLSPEC_ALIGN(8) dstBufferRange; + VkVideoPictureResourceInfoKHR32 DECLSPEC_ALIGN(8) srcPictureResource; + PTR32 pSetupReferenceSlot; + uint32_t referenceSlotCount; + PTR32 pReferenceSlots; + uint32_t precedingExternallyEncodedBytes; +} VkVideoEncodeInfoKHR32;

-typedef struct VkPresentRegionKHR32 +typedef struct VkVideoEncodeIntraRefreshCapabilitiesKHR32 { - uint32_t rectangleCount; - PTR32 pRectangles; -} VkPresentRegionKHR32; + VkStructureType sType; + PTR32 pNext; + VkVideoEncodeIntraRefreshModeFlagsKHR intraRefreshModes; + uint32_t maxIntraRefreshCycleDuration; + uint32_t maxIntraRefreshActiveReferencePictures; + VkBool32 partitionIndependentIntraRefreshRegions; + VkBool32 nonRectangularIntraRefreshRegions; +} VkVideoEncodeIntraRefreshCapabilitiesKHR32;

-typedef struct VkPresentRegionsKHR32 +typedef struct VkVideoEncodeIntraRefreshInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t swapchainCount; - PTR32 pRegions; -} VkPresentRegionsKHR32; + uint32_t intraRefreshCycleDuration; + uint32_t intraRefreshIndex; +} VkVideoEncodeIntraRefreshInfoKHR32;

-typedef struct VkDeviceGroupPresentInfoKHR32 +typedef struct VkVideoEncodeQualityLevelInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t swapchainCount; - PTR32 pDeviceMasks; - VkDeviceGroupPresentModeFlagBitsKHR mode; -} VkDeviceGroupPresentInfoKHR32; + uint32_t qualityLevel; +} VkVideoEncodeQualityLevelInfoKHR32;

-typedef struct VkPresentIdKHR32 +typedef struct VkVideoEncodeQualityLevelPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t swapchainCount; - PTR32 pPresentIds; -} VkPresentIdKHR32; + VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode; + uint32_t preferredRateControlLayerCount; +} VkVideoEncodeQualityLevelPropertiesKHR32;

-typedef struct VkPresentId2KHR32 +typedef struct VkVideoEncodeQuantizationMapCapabilitiesKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t swapchainCount; - PTR32 pPresentIds; -} VkPresentId2KHR32; + VkExtent2D maxQuantizationMapExtent; +} VkVideoEncodeQuantizationMapCapabilitiesKHR32;

-typedef struct VkSwapchainPresentFenceInfoKHR32 +typedef struct VkVideoEncodeQuantizationMapInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t swapchainCount; - PTR32 pFences; -} VkSwapchainPresentFenceInfoKHR32; -typedef VkSwapchainPresentFenceInfoKHR32 VkSwapchainPresentFenceInfoEXT32; + VkImageView DECLSPEC_ALIGN(8) quantizationMap; + VkExtent2D quantizationMapExtent; +} VkVideoEncodeQuantizationMapInfoKHR32;

-typedef struct VkSwapchainPresentModeInfoKHR32 +typedef struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t swapchainCount; - PTR32 pPresentModes; -} VkSwapchainPresentModeInfoKHR32; -typedef VkSwapchainPresentModeInfoKHR32 VkSwapchainPresentModeInfoEXT32; + VkExtent2D quantizationMapTexelSize; +} VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32;

-typedef struct VkPresentInfoKHR32 +typedef struct VkVideoEncodeRateControlInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t waitSemaphoreCount; - PTR32 pWaitSemaphores; - uint32_t swapchainCount; - PTR32 pSwapchains; - PTR32 pImageIndices; - PTR32 pResults; -} VkPresentInfoKHR32; + VkVideoEncodeRateControlFlagsKHR flags; + VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode; + uint32_t layerCount; + PTR32 pLayers; + uint32_t virtualBufferSizeInMs; + uint32_t initialVirtualBufferSizeInMs; +} VkVideoEncodeRateControlInfoKHR32;

-typedef struct VkDeviceGroupSubmitInfo32 +typedef struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t waitSemaphoreCount; - PTR32 pWaitSemaphoreDeviceIndices; - uint32_t commandBufferCount; - PTR32 pCommandBufferDeviceMasks; - uint32_t signalSemaphoreCount; - PTR32 pSignalSemaphoreDeviceIndices; -} VkDeviceGroupSubmitInfo32; -typedef VkDeviceGroupSubmitInfo32 VkDeviceGroupSubmitInfoKHR32; + VkVideoEncodeIntraRefreshModeFlagBitsKHR intraRefreshMode; +} VkVideoEncodeSessionIntraRefreshCreateInfoKHR32;

-typedef struct VkProtectedSubmitInfo32 +typedef struct VkVideoEncodeSessionParametersFeedbackInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 protectedSubmit; -} VkProtectedSubmitInfo32; + VkBool32 hasOverrides; +} VkVideoEncodeSessionParametersFeedbackInfoKHR32;

-typedef struct VkPerformanceQuerySubmitInfoKHR32 +typedef struct VkVideoEncodeSessionParametersGetInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t counterPassIndex; -} VkPerformanceQuerySubmitInfoKHR32; + VkVideoSessionParametersKHR DECLSPEC_ALIGN(8) videoSessionParameters; +} VkVideoEncodeSessionParametersGetInfoKHR32;

-typedef struct VkLatencySubmissionPresentIdNV32 +typedef struct VkVideoEncodeUsageInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint64_t DECLSPEC_ALIGN(8) presentID; -} VkLatencySubmissionPresentIdNV32; + VkVideoEncodeUsageFlagsKHR videoUsageHints; + VkVideoEncodeContentFlagsKHR videoContentHints; + VkVideoEncodeTuningModeKHR tuningMode; +} VkVideoEncodeUsageInfoKHR32;

-typedef struct VkSubmitInfo32 +typedef struct VkVideoEndCodingInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t waitSemaphoreCount; - PTR32 pWaitSemaphores; - PTR32 pWaitDstStageMask; - uint32_t commandBufferCount; - PTR32 pCommandBuffers; - uint32_t signalSemaphoreCount; - PTR32 pSignalSemaphores; -} VkSubmitInfo32; + VkVideoEndCodingFlagsKHR flags; +} VkVideoEndCodingInfoKHR32;

-typedef struct VkSemaphoreSubmitInfo32 +typedef struct VkVideoFormatAV1QuantizationMapPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - VkSemaphore DECLSPEC_ALIGN(8) semaphore; - uint64_t DECLSPEC_ALIGN(8) value; - VkPipelineStageFlags2 DECLSPEC_ALIGN(8) stageMask; - uint32_t deviceIndex; -} VkSemaphoreSubmitInfo32; -typedef VkSemaphoreSubmitInfo32 VkSemaphoreSubmitInfoKHR32; + VkVideoEncodeAV1SuperblockSizeFlagsKHR compatibleSuperblockSizes; +} VkVideoFormatAV1QuantizationMapPropertiesKHR32;

-typedef struct VkRenderPassStripeSubmitInfoARM32 +typedef struct VkVideoFormatH265QuantizationMapPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - uint32_t stripeSemaphoreInfoCount; - PTR32 pStripeSemaphoreInfos; -} VkRenderPassStripeSubmitInfoARM32; + VkVideoEncodeH265CtbSizeFlagsKHR compatibleCtbSizes; +} VkVideoFormatH265QuantizationMapPropertiesKHR32;

-typedef struct VkCommandBufferSubmitInfo32 +typedef struct VkVideoFormatPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - PTR32 commandBuffer; - uint32_t deviceMask; -} VkCommandBufferSubmitInfo32; -typedef VkCommandBufferSubmitInfo32 VkCommandBufferSubmitInfoKHR32; + VkFormat format; + VkComponentMapping componentMapping; + VkImageCreateFlags imageCreateFlags; + VkImageType imageType; + VkImageTiling imageTiling; + VkImageUsageFlags imageUsageFlags; +} VkVideoFormatPropertiesKHR32;

-typedef struct VkSubmitInfo232 +typedef struct VkVideoFormatQuantizationMapPropertiesKHR32 { VkStructureType sType; PTR32 pNext; - VkSubmitFlags flags; - uint32_t waitSemaphoreInfoCount; - PTR32 pWaitSemaphoreInfos; - uint32_t commandBufferInfoCount; - PTR32 pCommandBufferInfos; - uint32_t signalSemaphoreInfoCount; - PTR32 pSignalSemaphoreInfos; -} VkSubmitInfo232; -typedef VkSubmitInfo232 VkSubmitInfo2KHR32; + VkExtent2D quantizationMapTexelSize; +} VkVideoFormatQuantizationMapPropertiesKHR32;

-typedef struct VkReleaseCapturedPipelineDataInfoKHR32 +typedef struct VkVideoInlineQueryInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkPipeline DECLSPEC_ALIGN(8) pipeline; -} VkReleaseCapturedPipelineDataInfoKHR32; + VkQueryPool DECLSPEC_ALIGN(8) queryPool; + uint32_t firstQuery; + uint32_t queryCount; +} VkVideoInlineQueryInfoKHR32;

-typedef struct VkReleaseSwapchainImagesInfoKHR32 +typedef struct VkVideoProfileListInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkSwapchainKHR DECLSPEC_ALIGN(8) swapchain; - uint32_t imageIndexCount; - PTR32 pImageIndices; -} VkReleaseSwapchainImagesInfoKHR32; -typedef VkReleaseSwapchainImagesInfoKHR32 VkReleaseSwapchainImagesInfoEXT32; + uint32_t profileCount; + PTR32 pProfiles; +} VkVideoProfileListInfoKHR32;

-typedef struct VkDebugUtilsObjectTagInfoEXT32 +typedef struct VkVideoReferenceIntraRefreshInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkObjectType objectType; - uint64_t DECLSPEC_ALIGN(8) objectHandle; - uint64_t DECLSPEC_ALIGN(8) tagName; - PTR32 tagSize; - PTR32 pTag; -} VkDebugUtilsObjectTagInfoEXT32; + uint32_t dirtyIntraRefreshRegions; +} VkVideoReferenceIntraRefreshInfoKHR32;

-typedef struct VkHdrVividDynamicMetadataHUAWEI32 +typedef struct VkVideoSessionCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - PTR32 dynamicMetadataSize; - PTR32 pDynamicMetadata; -} VkHdrVividDynamicMetadataHUAWEI32; + uint32_t queueFamilyIndex; + VkVideoSessionCreateFlagsKHR flags; + PTR32 pVideoProfile; + VkFormat pictureFormat; + VkExtent2D maxCodedExtent; + VkFormat referencePictureFormat; + uint32_t maxDpbSlots; + uint32_t maxActiveReferencePictures; + PTR32 pStdHeaderVersion; +} VkVideoSessionCreateInfoKHR32;

-typedef struct VkHdrMetadataEXT32 +typedef struct VkVideoSessionMemoryRequirementsKHR32 { VkStructureType sType; PTR32 pNext; - VkXYColorEXT displayPrimaryRed; - VkXYColorEXT displayPrimaryGreen; - VkXYColorEXT displayPrimaryBlue; - VkXYColorEXT whitePoint; - float maxLuminance; - float minLuminance; - float maxContentLightLevel; - float maxFrameAverageLightLevel; -} VkHdrMetadataEXT32; + uint32_t memoryBindIndex; + VkMemoryRequirements32 DECLSPEC_ALIGN(8) memoryRequirements; +} VkVideoSessionMemoryRequirementsKHR32;

-typedef struct VkSetLatencyMarkerInfoNV32 +typedef struct VkVideoSessionParametersCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - uint64_t DECLSPEC_ALIGN(8) presentID; - VkLatencyMarkerNV marker; -} VkSetLatencyMarkerInfoNV32; + VkVideoSessionParametersCreateFlagsKHR flags; + VkVideoSessionParametersKHR DECLSPEC_ALIGN(8) videoSessionParametersTemplate; + VkVideoSessionKHR DECLSPEC_ALIGN(8) videoSession; +} VkVideoSessionParametersCreateInfoKHR32;

-typedef struct VkLatencySleepModeInfoNV32 +typedef struct VkVideoSessionParametersUpdateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkBool32 lowLatencyMode; - VkBool32 lowLatencyBoost; - uint32_t minimumIntervalUs; -} VkLatencySleepModeInfoNV32; + uint32_t updateSequenceCount; +} VkVideoSessionParametersUpdateInfoKHR32;

-typedef struct VkSemaphoreSignalInfo32 +typedef struct VkWin32SurfaceCreateInfoKHR32 { VkStructureType sType; PTR32 pNext; - VkSemaphore DECLSPEC_ALIGN(8) semaphore; - uint64_t DECLSPEC_ALIGN(8) value; -} VkSemaphoreSignalInfo32; -typedef VkSemaphoreSignalInfo32 VkSemaphoreSignalInfoKHR32; + VkWin32SurfaceCreateFlagsKHR flags; + PTR32 hinstance; + PTR32 hwnd; +} VkWin32SurfaceCreateInfoKHR32;

-typedef struct VkDeviceAddressBindingCallbackDataEXT32 +typedef struct VkWriteDescriptorSetAccelerationStructureKHR32 { VkStructureType sType; PTR32 pNext; - VkDeviceAddressBindingFlagsEXT flags; - VkDeviceAddress DECLSPEC_ALIGN(8) baseAddress; - VkDeviceSize DECLSPEC_ALIGN(8) size; - VkDeviceAddressBindingTypeEXT bindingType; -} VkDeviceAddressBindingCallbackDataEXT32; + uint32_t accelerationStructureCount; + PTR32 pAccelerationStructures; +} VkWriteDescriptorSetAccelerationStructureKHR32;

-typedef struct VkDebugUtilsMessengerCallbackDataEXT32 +typedef struct VkWriteDescriptorSetAccelerationStructureNV32 { VkStructureType sType; PTR32 pNext; - VkDebugUtilsMessengerCallbackDataFlagsEXT flags; - PTR32 pMessageIdName; - int32_t messageIdNumber; - PTR32 pMessage; - uint32_t queueLabelCount; - PTR32 pQueueLabels; - uint32_t cmdBufLabelCount; - PTR32 pCmdBufLabels; - uint32_t objectCount; - PTR32 pObjects; -} VkDebugUtilsMessengerCallbackDataEXT32; + uint32_t accelerationStructureCount; + PTR32 pAccelerationStructures; +} VkWriteDescriptorSetAccelerationStructureNV32;

-typedef struct VkHostImageLayoutTransitionInfo32 +typedef struct VkWriteDescriptorSetInlineUniformBlock32 { VkStructureType sType; PTR32 pNext; - VkImage DECLSPEC_ALIGN(8) image; - VkImageLayout oldLayout; - VkImageLayout newLayout; - VkImageSubresourceRange subresourceRange; -} VkHostImageLayoutTransitionInfo32; -typedef VkHostImageLayoutTransitionInfo32 VkHostImageLayoutTransitionInfoEXT32; + uint32_t dataSize; + PTR32 pData; +} VkWriteDescriptorSetInlineUniformBlock32; +typedef VkWriteDescriptorSetInlineUniformBlock32 VkWriteDescriptorSetInlineUniformBlockEXT32;

-typedef struct VkMemoryUnmapInfo32 +typedef struct VkWriteDescriptorSetPartitionedAccelerationStructureNV32 { VkStructureType sType; PTR32 pNext; - VkMemoryUnmapFlags flags; - VkDeviceMemory DECLSPEC_ALIGN(8) memory; -} VkMemoryUnmapInfo32; -typedef VkMemoryUnmapInfo32 VkMemoryUnmapInfoKHR32; + uint32_t accelerationStructureCount; + PTR32 pAccelerationStructures; +} VkWriteDescriptorSetPartitionedAccelerationStructureNV32;

-typedef struct VkCopyDescriptorSet32 +typedef struct VkWriteDescriptorSetTensorARM32 { VkStructureType sType; PTR32 pNext; - VkDescriptorSet DECLSPEC_ALIGN(8) srcSet; - uint32_t srcBinding; - uint32_t srcArrayElement; - VkDescriptorSet DECLSPEC_ALIGN(8) dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; -} VkCopyDescriptorSet32; + uint32_t tensorViewCount; + PTR32 pTensorViews; +} VkWriteDescriptorSetTensorARM32;

typedef struct VkWriteIndirectExecutionSetPipelineEXT32 { @@ -9497,32 +9523,6 @@ typedef struct VkWriteIndirectExecutionSetShaderEXT32 VkShaderEXT DECLSPEC_ALIGN(8) shader; } VkWriteIndirectExecutionSetShaderEXT32;

-typedef struct VkVideoSessionParametersUpdateInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - uint32_t updateSequenceCount; -} VkVideoSessionParametersUpdateInfoKHR32; - -typedef struct VkPresentWait2InfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - uint64_t DECLSPEC_ALIGN(8) presentId; - uint64_t DECLSPEC_ALIGN(8) timeout; -} VkPresentWait2InfoKHR32; - -typedef struct VkSemaphoreWaitInfo32 -{ - VkStructureType sType; - PTR32 pNext; - VkSemaphoreWaitFlags flags; - uint32_t semaphoreCount; - PTR32 pSemaphores; - PTR32 pValues; -} VkSemaphoreWaitInfo32; -typedef VkSemaphoreWaitInfo32 VkSemaphoreWaitInfoKHR32; - static uint64_t wine_vk_unwrap_handle(uint32_t type, uint64_t handle) { switch(type)

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8901

Rémi Bernon

9:37 a.m.

New subject: [PATCH 2/6] winevulkan: Simplify struct conversion enumeration.

From: Rémi Bernon rbernon@codeweavers.com

Returning the conversions as they as used, instead of a separate and possibly different enumeration. --- dlls/winevulkan/make_vulkan | 183 +- dlls/winevulkan/vulkan_thunks.c | 5290 +++++++++++++++---------------- 2 files changed, 2710 insertions(+), 2763 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 9be7ef8ca66..68d0673719a 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -657,18 +657,6 @@ class VkFunction(object):

return VkFunction(_type=func_type, name=func_name, params=params)

- def get_conversions(self): - """ Get a list of conversion functions required for this function if any. - Parameters which are structures may require conversion between win32 - and the host platform. This function returns a list of conversions - required. - """ - - conversions = [] - for param in self.params: - conversions.extend(param.get_conversions(self.unwrap)) - return conversions - def is_alias(self): return bool(self.alias)

@@ -806,7 +794,7 @@ class VkFunction(object): body += " return params.result;\n" return body

- def body(self, conv, params_prefix=""): + def body(self, conv, conversions, params_prefix=""): body = "" needs_alloc = False deferred_op = None @@ -857,7 +845,7 @@ class VkFunction(object): unwrap = self.name not in MANUAL_UNIX_THUNKS for p in self.params: if p.needs_conversion(conv, self.unwrap, Direction.INPUT): - body += p.copy(Direction.INPUT, conv, self.unwrap, prefix=params_prefix) + body += p.copy(Direction.INPUT, conv, self.unwrap, conversions, prefix=params_prefix) elif p.is_dynamic_array() and p.needs_conversion(conv, self.unwrap, Direction.OUTPUT): body += " {0}_host = ({2}{0} && {1}) ? conversion_context_alloc(ctx, sizeof(*{0}_host) * {1}) : NULL;\n".format( p.name, p.get_dyn_array_len(params_prefix, conv), params_prefix) @@ -888,7 +876,7 @@ class VkFunction(object): # Call any host_to_win conversion calls. for p in self.params: if p.needs_conversion(conv, self.unwrap, Direction.OUTPUT): - body += p.copy(Direction.OUTPUT, conv, self.unwrap, prefix=params_prefix) + body += p.copy(Direction.OUTPUT, conv, self.unwrap, conversions, prefix=params_prefix)

if needs_alloc: if deferred_op is not None: @@ -938,7 +926,7 @@ class VkFunction(object): stub += "}\n\n" return stub

- def thunk(self, prefix=None, conv=False): + def thunk(self, conversions, prefix=None, conv=False): thunk = "" if not conv: thunk += "#ifdef _WIN64\n" @@ -959,7 +947,7 @@ class VkFunction(object): thunk += " } *params = args;\n" else: thunk += " struct {0}_params *params = args;\n".format(self.name) - thunk += self.body(conv, params_prefix="params->") + thunk += self.body(conv, conversions, params_prefix="params->") thunk += "}\n" if not conv: thunk += "#endif /* _WIN64 */\n" @@ -1307,39 +1295,6 @@ class VkVariable(object): def needs_win32_type(self): return (self.is_struct() or (self.is_union() and self.selector)) and self.struct.needs_win32_type()

- def get_conversions(self, unwrap, parent_const=False): - """ Get a list of conversions required for this parameter if any. - Parameters which are structures may require conversion between win32 - and the host platform. This function returns a list of conversions - required. - """ - - conversions = [] - - # Collect any member conversions first, so we can guarantee - # those functions will be defined prior to usage by the - # 'parent' param requiring conversion. - if self.is_struct() or (self.is_union() and self.selector): - struct = self.struct - is_const = self.is_const() if self.is_pointer() else parent_const - - conversions.extend(struct.get_conversions(unwrap, is_const)) - - for conv in [False, True]: - if struct.needs_conversion(conv, unwrap, Direction.INPUT, is_const): - conversions.append(StructConversionFunction(struct, Direction.INPUT, conv, unwrap, is_const)) - if struct.needs_conversion(conv, unwrap, Direction.OUTPUT, is_const): - conversions.append(StructConversionFunction(struct, Direction.OUTPUT, conv, unwrap, is_const)) - - if self.is_static_array() or self.is_dynamic_array(): - for conv in [False, True]: - if self.needs_conversion(conv, unwrap, Direction.INPUT, parent_const): - conversions.append(ArrayConversionFunction(self, Direction.INPUT, conv, unwrap)) - if self.needs_conversion(conv, unwrap, Direction.OUTPUT, parent_const): - conversions.append(ArrayConversionFunction(self, Direction.OUTPUT, conv, unwrap)) - - return conversions - def needs_ptr32_type(self): """ Check if variable needs to use PTR32 type. """

@@ -1453,18 +1408,20 @@ class VkMember(VkVariable): values=values, object_type=object_type, bit_width=bit_width, returnedonly=returnedonly, parent=parent, selection=selection, selector=selector)

- def copy(self, input, output, direction, conv, unwrap): + def copy(self, input, output, direction, conv, unwrap, parent_const, conversions): """ Helper method for use by conversion logic to generate a C-code statement to copy this member. - `conv` indicates whether the statement is in a struct alignment conversion path. """

win_type = "win32" if conv else "win64" suffix = convert_suffix(direction, win_type, unwrap, self.is_wrapped()) + is_const = self.is_const() if self.is_pointer() else parent_const

if self.needs_conversion(conv, unwrap, direction, False): if self.is_dynamic_array(): # Array length is either a variable name (string) or an int. count = self.get_dyn_array_len(input, conv) pointer_part = "pointer_" if self.pointer_array else "" + conversions.append(ArrayConversionFunction(self, direction, conv, unwrap)) if direction == Direction.OUTPUT: return "convert_{2}_{6}array_{5}({3}{1}, {0}, {4});\n".format(self.value(output, conv), self.name, self.type, input, count, suffix, pointer_part) @@ -1477,6 +1434,7 @@ class VkMember(VkVariable): LOGGER.warn("TODO: implement conversion of multidimensional static array for {0}.{1}".format(self.type, self.name)) elif direction == Direction.OUTPUT: # Needed by VkMemoryHeap.memoryHeaps + conversions.append(ArrayConversionFunction(self, direction, conv, unwrap)) return "convert_{0}_array_{5}({2}{1}, {3}{1}, {4});\n".format(self.type, self.name, input, output, count, suffix) else: @@ -1498,6 +1456,7 @@ class VkMember(VkVariable): return "{0}{1} = wine_vk_unwrap_handle({2}{3}, {2}{1});\n".format(output, self.name, input, self.object_type) else: selector_part = ", {0}{1}".format(input, self.selector) if self.selector else "" + conversions.append(StructConversionFunction(self.struct, direction, conv, unwrap, is_const)) if direction == Direction.OUTPUT: return "convert_{0}_{4}(&{2}{1}, &{3}{1}{5});\n".format(self.type, self.name, input, output, suffix, selector_part) @@ -1714,16 +1673,19 @@ class VkParam(VkVariable): else: LOGGER.warn("Unhandled type: {0}".format(self.type_info))

- def copy(self, direction, conv, unwrap, prefix=""): + def copy(self, direction, conv, unwrap, conversions, prefix=""): win_type = "win32" if conv else "win64" suffix = convert_suffix(direction, win_type, unwrap, self.is_wrapped()) + is_const = self.is_const() if self.is_pointer() else False

if direction == Direction.INPUT: ctx_param = "ctx, " if self.needs_alloc(conv, unwrap) else "" if self.is_dynamic_array(): + conversions.append(ArrayConversionFunction(self, direction, conv, unwrap)) return " {0}_host = convert_{2}_array_{4}({5}{1}, {3});\n".format(self.name, self.value(prefix, conv), self.type, self.get_dyn_array_len(prefix, conv), suffix, ctx_param) elif self.optional: + conversions.append(StructConversionFunction(self.struct, direction, conv, unwrap, is_const)) ret = " if ({0}{1})\n".format(prefix, self.name) ret += " {\n" ret += " {0}_host = conversion_context_alloc(ctx, sizeof(*{0}_host));\n".format(self.name) @@ -1732,6 +1694,7 @@ class VkParam(VkVariable): ret += " }\n" return ret elif self.is_struct(): + conversions.append(StructConversionFunction(self.struct, direction, conv, unwrap, is_const)) return " convert_{0}_{3}({4}{1}, &{2}_host);\n".format(self.type, self.value(prefix, conv), self.name, suffix, ctx_param) elif self.is_pointer_size() and self.type != "size_t": @@ -1740,11 +1703,13 @@ class VkParam(VkVariable): return " {0}_host = *{1};\n".format(self.name, self.value(prefix, conv)) else: if self.is_dynamic_array(): + conversions.append(ArrayConversionFunction(self, direction, conv, unwrap)) return " convert_{0}_array_{1}({2}_host, {3}, {4});\n".format( self.type, suffix, self.name, self.value(prefix, conv).replace('const ', ''), self.get_dyn_array_len(prefix, conv)) elif self.is_struct(): ref_part = "" if self.optional else "&" + conversions.append(StructConversionFunction(self.struct, direction, conv, unwrap, is_const)) return " convert_{0}_host_to_{3}({4}{2}_host, {1});\n".format( self.type, self.value(prefix, conv), self.name, win_type, ref_part) elif self.is_pointer_size() and self.type != "size_t": @@ -2179,23 +2144,6 @@ class VkStruct(Sequence): type_info = types[m.type] m.set_type_info(type_info)

- def get_conversions(self, unwrap, parent_const): - conversions = [] - - # Collect any conversion for any extension structs. - for e in self.struct_extensions: - if not e.required: - continue - conversions.extend(e.get_conversions(Unwrap.HOST, parent_const)) - - # Collect any conversion for any member structs. - for m in self: - if m.type == self.name: - continue - conversions.extend(m.get_conversions(unwrap, parent_const)) - - return conversions -

class StructConversionFunction(object): def __init__(self, struct, direction, conv, unwrap, const): @@ -2230,7 +2178,7 @@ class StructConversionFunction(object): return False return True

- def definition(self): + def definition(self, conversions): """ Helper function for generating a struct conversion function. """

# It doesn't make sense to generate conversion functions for non-struct variables @@ -2251,7 +2199,7 @@ class StructConversionFunction(object): win_type = "const " + win_type

if self.conv: - body += "static inline void {0}(".format(self.name) + body += "static void {0}(".format(self.name)

if self.direction == Direction.OUTPUT: params = ["const {0} *in".format(self.type), "{0} *out".format(win_type)] @@ -2268,7 +2216,7 @@ class StructConversionFunction(object): body += ")\n"

else: - body += "static inline void {0}(".format(self.name) + body += "static void {0}(".format(self.name)

params = ["const {0} *in".format(self.type), "{0} *out".format(self.type)]

@@ -2312,7 +2260,7 @@ class StructConversionFunction(object): body += " || ".join("selector == {}".format(s) for s in m.selection) body += ")\n "

- body += " " + m.copy("in->", "out->", self.direction, self.conv, self.unwrap) + body += " " + m.copy("in->", "out->", self.direction, self.conv, self.unwrap, self.const, conversions)

if needs_extensions: if self.conv and self.direction == Direction.INPUT: @@ -2366,7 +2314,7 @@ class StructConversionFunction(object): if m.name == "pNext": copy_body += ident + "out_ext->pNext = NULL;\n" continue - copy_body += ident + m.copy("in_ext->", "out_ext->", self.direction, self.conv, Unwrap.HOST) + copy_body += ident + m.copy("in_ext->", "out_ext->", self.direction, self.conv, Unwrap.HOST, self.const, conversions)

# Generate the definition of "in_ext" if we need it if "in_ext->" in copy_body: @@ -2419,7 +2367,7 @@ class ArrayConversionFunction(object): def __eq__(self, other): return self.name == other.name

- def definition(self): + def definition(self, conversions): """ Helper function for generating a conversion function for array operands. """

body = "" @@ -2459,10 +2407,10 @@ class ArrayConversionFunction(object):

# Generate function prototype. if return_type: - body += "static inline {0}{1} {2}{3}(".format( + body += "static {0}{1} {2}{3}(".format( "const " if self.array.is_const() else "", return_type, pointer_part, self.name) else: - body += "static inline void {0}(".format(self.name) + body += "static void {0}(".format(self.name) if needs_alloc: body += "struct conversion_context *ctx, " body += ", ".join(p for p in params) @@ -2488,6 +2436,7 @@ class ArrayConversionFunction(object):

if self.array.is_struct(): struct = self.array.struct + is_const = self.array.is_const() if self.array.is_pointer() else False win_part = "win32" if self.conv else "win64" suffix = convert_suffix(self.direction, win_part, self.unwrap, struct.is_wrapped()) ctx_part = "" @@ -2495,6 +2444,7 @@ class ArrayConversionFunction(object): ctx_part = "ctx, "

if not pointer_array: + conversions.append(StructConversionFunction(struct, self.direction, self.conv, self.unwrap, is_const)) body += " convert_{0}_{1}({2}&in[i], &out[i]);\n".format( struct.name, suffix, ctx_part) else: @@ -2506,6 +2456,7 @@ class ArrayConversionFunction(object): in_param = "({0} *)UlongToPtr(in[i])".format(win_type) else: in_param = "in[i]" + conversions.append(StructConversionFunction(struct, self.direction, self.conv, self.unwrap, is_const)) body += " convert_{0}_{1}({2}{3}, out[i]);\n".format( struct.name, suffix, ctx_part, in_param) body += " }\n" @@ -2559,32 +2510,6 @@ class VkGenerator(object): # Build a list conversion functions for struct conversion. self.conversions = [] self.win32_structs = [] - for func in self.registry.funcs.values(): - if not func.needs_exposing(): - continue - - conversions = func.get_conversions() - for conv in conversions: - # Append if we don't already have this conversion. - if not any(c == conv for c in self.conversions): - self.conversions.append(conv) - - if not isinstance(conv, StructConversionFunction): - continue - - for e in conv.operand.struct_extensions: - if not e.required or not e.needs_win32_type(): - continue - if not any(s.name == e.name for s in self.win32_structs): - self.win32_structs.append(e) - - if not conv.operand.needs_win32_type(): - continue - - # Structs can be used in different ways by different conversions - # e.g. array vs non-array. Just make sure we pull in each struct once. - if not any(s.name == conv.operand.name for s in self.win32_structs): - self.win32_structs.append(conv.operand)

def _generate_copyright(self, f, spec_file=False): f.write("# " if spec_file else "/* ") @@ -2614,10 +2539,44 @@ class VkGenerator(object):

f.write("WINE_DEFAULT_DEBUG_CHANNEL(vulkan);\n\n")

+ # Create thunks for instance and device functions. + # Global functions don't go through the thunks. + thunks = "" + conversions = [] + for vk_func in self.registry.funcs.values(): + if not vk_func.needs_exposing(): + continue + if vk_func.name in MANUAL_LOADER_FUNCTIONS: + continue + + thunks += vk_func.thunk(conversions, prefix="thunk64_") + thunks += vk_func.thunk(conversions, prefix="thunk32_", conv=True) + def unique(list, key=lambda x: x, seen=set()): return (e for e in list if not (key(e) in seen or seen.add(key(e))))

- win32_structs = sorted(self.win32_structs, key=lambda struct: (-struct.order, struct.name)) + def enum_conversions(conversions, visited=set()): + for conversion in unique(conversions, key=lambda conv: conv.name): + dependencies = [] + definition = conversion.definition(dependencies) + yield from enum_conversions(dependencies, visited) + yield definition, conversion + + conv_helpers = "" + win32_structs = [] + for definition, conversion in enum_conversions(conversions): + if isinstance(conversion, StructConversionFunction): + for e in conversion.operand.struct_extensions: + if not e.required or not e.needs_win32_type(): + continue + win32_structs.append(e) + if conversion.operand.needs_win32_type(): + # Structs can be used in different ways by different conversions + # e.g. array vs non-array. Just make sure we pull in each struct once. + win32_structs.append(conversion.operand) + conv_helpers += definition + + win32_structs = sorted(win32_structs, key=lambda struct: (-struct.order, struct.name)) for struct in unique(win32_structs, key=lambda struct: struct.name): f.write(struct.definition(conv=True, align=True)) f.write("\n") @@ -2642,20 +2601,8 @@ class VkGenerator(object): f.write(" }\n") f.write("}\n\n")

- # Generate any conversion helper functions. - for conv in self.conversions: - f.write(conv.definition()) - - # Create thunks for instance and device functions. - # Global functions don't go through the thunks. - for vk_func in self.registry.funcs.values(): - if not vk_func.needs_exposing(): - continue - if vk_func.name in MANUAL_LOADER_FUNCTIONS: - continue - - f.write(vk_func.thunk(prefix="thunk64_")) - f.write(vk_func.thunk(prefix="thunk32_", conv=True)) + f.write(conv_helpers) + f.write(thunks)

# Create array of device extensions. f.write("static const char * const vk_device_extensions[] =\n{\n") diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index dfd1d57e7d6..a9d1616def4 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -9556,7 +9556,7 @@ static uint64_t wine_vk_unwrap_handle(uint32_t type, uint64_t handle) } }

-static inline void convert_VkAcquireNextImageInfoKHR_win32_to_unwrapped_host(const VkAcquireNextImageInfoKHR32 *in, VkAcquireNextImageInfoKHR *out) +static void convert_VkAcquireNextImageInfoKHR_win32_to_unwrapped_host(const VkAcquireNextImageInfoKHR32 *in, VkAcquireNextImageInfoKHR *out) { if (!in) return;

@@ -9571,7 +9571,7 @@ static inline void convert_VkAcquireNextImageInfoKHR_win32_to_unwrapped_host(con FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host(const VkPerformanceConfigurationAcquireInfoINTEL32 *in, VkPerformanceConfigurationAcquireInfoINTEL *out) +static void convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_host(const VkPerformanceConfigurationAcquireInfoINTEL32 *in, VkPerformanceConfigurationAcquireInfoINTEL *out) { if (!in) return;

@@ -9582,7 +9582,7 @@ static inline void convert_VkPerformanceConfigurationAcquireInfoINTEL_win32_to_h FIXME("Unexpected pNext\n"); }

-static inline void convert_VkAcquireProfilingLockInfoKHR_win32_to_host(const VkAcquireProfilingLockInfoKHR32 *in, VkAcquireProfilingLockInfoKHR *out) +static void convert_VkAcquireProfilingLockInfoKHR_win32_to_host(const VkAcquireProfilingLockInfoKHR32 *in, VkAcquireProfilingLockInfoKHR *out) { if (!in) return;

@@ -9594,7 +9594,7 @@ static inline void convert_VkAcquireProfilingLockInfoKHR_win32_to_host(const VkA FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(const VkCommandBufferAllocateInfo32 *in, VkCommandBufferAllocateInfo *out) +static void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(const VkCommandBufferAllocateInfo32 *in, VkCommandBufferAllocateInfo *out) { if (!in) return;

@@ -9607,7 +9607,7 @@ static inline void convert_VkCommandBufferAllocateInfo_win32_to_unwrapped_host(c FIXME("Unexpected pNext\n"); }

-static inline VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_unwrapped_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) +static VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_unwrapped_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) { VkCommandBuffer *out; unsigned int i; @@ -9623,7 +9623,7 @@ static inline VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_unwrapped_ return out; }

-static inline void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetAllocateInfo32 *in, VkDescriptorSetAllocateInfo *out) +static void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetAllocateInfo32 *in, VkDescriptorSetAllocateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -9659,7 +9659,7 @@ static inline void convert_VkDescriptorSetAllocateInfo_win32_to_host(struct conv } }

-static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryAllocateInfo32 *in, VkMemoryAllocateInfo *out) +static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryAllocateInfo32 *in, VkMemoryAllocateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -9800,7 +9800,7 @@ static inline void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_ } }

-static inline void convert_VkAntiLagPresentationInfoAMD_win32_to_host(const VkAntiLagPresentationInfoAMD32 *in, VkAntiLagPresentationInfoAMD *out) +static void convert_VkAntiLagPresentationInfoAMD_win32_to_host(const VkAntiLagPresentationInfoAMD32 *in, VkAntiLagPresentationInfoAMD *out) { if (!in) return;

@@ -9812,7 +9812,7 @@ static inline void convert_VkAntiLagPresentationInfoAMD_win32_to_host(const VkAn FIXME("Unexpected pNext\n"); }

-static inline const VkAntiLagPresentationInfoAMD *convert_VkAntiLagPresentationInfoAMD_array_win32_to_host(struct conversion_context *ctx, const VkAntiLagPresentationInfoAMD32 *in, uint32_t count) +static const VkAntiLagPresentationInfoAMD *convert_VkAntiLagPresentationInfoAMD_array_win32_to_host(struct conversion_context *ctx, const VkAntiLagPresentationInfoAMD32 *in, uint32_t count) { VkAntiLagPresentationInfoAMD *out; unsigned int i; @@ -9828,7 +9828,7 @@ static inline const VkAntiLagPresentationInfoAMD *convert_VkAntiLagPresentationI return out; }

-static inline void convert_VkAntiLagDataAMD_win32_to_host(struct conversion_context *ctx, const VkAntiLagDataAMD32 *in, VkAntiLagDataAMD *out) +static void convert_VkAntiLagDataAMD_win32_to_host(struct conversion_context *ctx, const VkAntiLagDataAMD32 *in, VkAntiLagDataAMD *out) { if (!in) return;

@@ -9842,7 +9842,7 @@ static inline void convert_VkAntiLagDataAMD_win32_to_host(struct conversion_cont }

#ifdef _WIN64 -static inline void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo *in, VkCommandBufferInheritanceInfo *out) +static void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo *in, VkCommandBufferInheritanceInfo *out) { const VkBaseInStructure *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -9985,7 +9985,37 @@ static inline void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct c } #endif /* _WIN64 */

-static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, VkCommandBufferInheritanceInfo *out) +#ifdef _WIN64 +static const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo *in, uint32_t count) +{ + VkCommandBufferInheritanceInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkCommandBufferInheritanceInfo_win64_to_host(ctx, &in[i], &out[i]); + } + + return out; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static void convert_VkCommandBufferBeginInfo_win64_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo *in, VkCommandBufferBeginInfo *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->flags = in->flags; + out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win64_to_host(ctx, in->pInheritanceInfo, 1); +} +#endif /* _WIN64 */ + +static void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, VkCommandBufferInheritanceInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -10127,25 +10157,7 @@ static inline void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct c } }

-#ifdef _WIN64 -static inline const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo *in, uint32_t count) -{ - VkCommandBufferInheritanceInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkCommandBufferInheritanceInfo_win64_to_host(ctx, &in[i], &out[i]); - } - - return out; -} -#endif /* _WIN64 */ - -static inline const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, uint32_t count) +static const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInheritanceInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferInheritanceInfo32 *in, uint32_t count) { VkCommandBufferInheritanceInfo *out; unsigned int i; @@ -10161,19 +10173,7 @@ static inline const VkCommandBufferInheritanceInfo *convert_VkCommandBufferInher return out; }

-#ifdef _WIN64 -static inline void convert_VkCommandBufferBeginInfo_win64_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo *in, VkCommandBufferBeginInfo *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = in->pNext; - out->flags = in->flags; - out->pInheritanceInfo = convert_VkCommandBufferInheritanceInfo_array_win64_to_host(ctx, in->pInheritanceInfo, 1); -} -#endif /* _WIN64 */ - -static inline void convert_VkCommandBufferBeginInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo32 *in, VkCommandBufferBeginInfo *out) +static void convert_VkCommandBufferBeginInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferBeginInfo32 *in, VkCommandBufferBeginInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -10208,7 +10208,7 @@ static inline void convert_VkCommandBufferBeginInfo_win32_to_host(struct convers }

#ifdef _WIN64 -static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win64_to_host(const VkBindAccelerationStructureMemoryInfoNV *in, VkBindAccelerationStructureMemoryInfoNV *out) +static void convert_VkBindAccelerationStructureMemoryInfoNV_win64_to_host(const VkBindAccelerationStructureMemoryInfoNV *in, VkBindAccelerationStructureMemoryInfoNV *out) { if (!in) return;

@@ -10222,23 +10222,8 @@ static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win64_to_host } #endif /* _WIN64 */

-static inline void convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(const VkBindAccelerationStructureMemoryInfoNV32 *in, VkBindAccelerationStructureMemoryInfoNV *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->accelerationStructure = in->accelerationStructure; - out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory; - out->memoryOffset = in->memoryOffset; - out->deviceIndexCount = in->deviceIndexCount; - out->pDeviceIndices = UlongToPtr(in->pDeviceIndices); - if (in->pNext) - FIXME("Unexpected pNext\n"); -} - #ifdef _WIN64 -static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV *in, uint32_t count) +static const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV *in, uint32_t count) { VkBindAccelerationStructureMemoryInfoNV *out; unsigned int i; @@ -10255,7 +10240,22 @@ static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccel } #endif /* _WIN64 */

-static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV32 *in, uint32_t count) +static void convert_VkBindAccelerationStructureMemoryInfoNV_win32_to_host(const VkBindAccelerationStructureMemoryInfoNV32 *in, VkBindAccelerationStructureMemoryInfoNV *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->accelerationStructure = in->accelerationStructure; + out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory; + out->memoryOffset = in->memoryOffset; + out->deviceIndexCount = in->deviceIndexCount; + out->pDeviceIndices = UlongToPtr(in->pDeviceIndices); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccelerationStructureMemoryInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkBindAccelerationStructureMemoryInfoNV32 *in, uint32_t count) { VkBindAccelerationStructureMemoryInfoNV *out; unsigned int i; @@ -10272,7 +10272,7 @@ static inline const VkBindAccelerationStructureMemoryInfoNV *convert_VkBindAccel }

#ifdef _WIN64 -static inline void convert_VkBindBufferMemoryInfo_win64_to_host(const VkBindBufferMemoryInfo *in, VkBindBufferMemoryInfo *out) +static void convert_VkBindBufferMemoryInfo_win64_to_host(const VkBindBufferMemoryInfo *in, VkBindBufferMemoryInfo *out) { if (!in) return;

@@ -10284,7 +10284,25 @@ static inline void convert_VkBindBufferMemoryInfo_win64_to_host(const VkBindBuff } #endif /* _WIN64 */

-static inline void convert_VkBindBufferMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, VkBindBufferMemoryInfo *out) +#ifdef _WIN64 +static const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo *in, uint32_t count) +{ + VkBindBufferMemoryInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkBindBufferMemoryInfo_win64_to_host(&in[i], &out[i]); + } + + return out; +} +#endif /* _WIN64 */ + +static void convert_VkBindBufferMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, VkBindBufferMemoryInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -10331,25 +10349,7 @@ static inline void convert_VkBindBufferMemoryInfo_win32_to_host(struct conversio } }

-#ifdef _WIN64 -static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo *in, uint32_t count) -{ - VkBindBufferMemoryInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkBindBufferMemoryInfo_win64_to_host(&in[i], &out[i]); - } - - return out; -} -#endif /* _WIN64 */ - -static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, uint32_t count) +static const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindBufferMemoryInfo32 *in, uint32_t count) { VkBindBufferMemoryInfo *out; unsigned int i; @@ -10366,7 +10366,7 @@ static inline const VkBindBufferMemoryInfo *convert_VkBindBufferMemoryInfo_array }

#ifdef _WIN64 -static inline void convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win64_to_host(const VkBindDataGraphPipelineSessionMemoryInfoARM *in, VkBindDataGraphPipelineSessionMemoryInfoARM *out) +static void convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win64_to_host(const VkBindDataGraphPipelineSessionMemoryInfoARM *in, VkBindDataGraphPipelineSessionMemoryInfoARM *out) { if (!in) return;

@@ -10380,23 +10380,8 @@ static inline void convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win64_to_ } #endif /* _WIN64 */

-static inline void convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win32_to_host(const VkBindDataGraphPipelineSessionMemoryInfoARM32 *in, VkBindDataGraphPipelineSessionMemoryInfoARM *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->session = in->session; - out->bindPoint = in->bindPoint; - out->objectIndex = in->objectIndex; - out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory; - out->memoryOffset = in->memoryOffset; - if (in->pNext) - FIXME("Unexpected pNext\n"); -} - #ifdef _WIN64 -static inline const VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindDataGraphPipelineSessionMemoryInfoARM_array_win64_to_host(struct conversion_context *ctx, const VkBindDataGraphPipelineSessionMemoryInfoARM *in, uint32_t count) +static const VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindDataGraphPipelineSessionMemoryInfoARM_array_win64_to_host(struct conversion_context *ctx, const VkBindDataGraphPipelineSessionMemoryInfoARM *in, uint32_t count) { VkBindDataGraphPipelineSessionMemoryInfoARM *out; unsigned int i; @@ -10413,7 +10398,22 @@ static inline const VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindD } #endif /* _WIN64 */

-static inline const VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindDataGraphPipelineSessionMemoryInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkBindDataGraphPipelineSessionMemoryInfoARM32 *in, uint32_t count) +static void convert_VkBindDataGraphPipelineSessionMemoryInfoARM_win32_to_host(const VkBindDataGraphPipelineSessionMemoryInfoARM32 *in, VkBindDataGraphPipelineSessionMemoryInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->session = in->session; + out->bindPoint = in->bindPoint; + out->objectIndex = in->objectIndex; + out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory; + out->memoryOffset = in->memoryOffset; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static const VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindDataGraphPipelineSessionMemoryInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkBindDataGraphPipelineSessionMemoryInfoARM32 *in, uint32_t count) { VkBindDataGraphPipelineSessionMemoryInfoARM *out; unsigned int i; @@ -10430,7 +10430,7 @@ static inline const VkBindDataGraphPipelineSessionMemoryInfoARM *convert_VkBindD }

#ifdef _WIN64 -static inline void convert_VkBindImageMemoryInfo_win64_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo *in, VkBindImageMemoryInfo *out) +static void convert_VkBindImageMemoryInfo_win64_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo *in, VkBindImageMemoryInfo *out) { const VkBaseInStructure *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -10503,7 +10503,25 @@ static inline void convert_VkBindImageMemoryInfo_win64_to_host(struct conversion } #endif /* _WIN64 */

-static inline void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, VkBindImageMemoryInfo *out) +#ifdef _WIN64 +static const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo *in, uint32_t count) +{ + VkBindImageMemoryInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkBindImageMemoryInfo_win64_to_host(ctx, &in[i], &out[i]); + } + + return out; +} +#endif /* _WIN64 */ + +static void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, VkBindImageMemoryInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -10575,25 +10593,7 @@ static inline void convert_VkBindImageMemoryInfo_win32_to_host(struct conversion } }

-#ifdef _WIN64 -static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo *in, uint32_t count) -{ - VkBindImageMemoryInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkBindImageMemoryInfo_win64_to_host(ctx, &in[i], &out[i]); - } - - return out; -} -#endif /* _WIN64 */ - -static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, uint32_t count) +static const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindImageMemoryInfo32 *in, uint32_t count) { VkBindImageMemoryInfo *out; unsigned int i; @@ -10610,7 +10610,7 @@ static inline const VkBindImageMemoryInfo *convert_VkBindImageMemoryInfo_array_w }

#ifdef _WIN64 -static inline void convert_VkBindTensorMemoryInfoARM_win64_to_host(const VkBindTensorMemoryInfoARM *in, VkBindTensorMemoryInfoARM *out) +static void convert_VkBindTensorMemoryInfoARM_win64_to_host(const VkBindTensorMemoryInfoARM *in, VkBindTensorMemoryInfoARM *out) { if (!in) return;

@@ -10622,21 +10622,8 @@ static inline void convert_VkBindTensorMemoryInfoARM_win64_to_host(const VkBindT } #endif /* _WIN64 */

-static inline void convert_VkBindTensorMemoryInfoARM_win32_to_host(const VkBindTensorMemoryInfoARM32 *in, VkBindTensorMemoryInfoARM *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->tensor = in->tensor; - out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory; - out->memoryOffset = in->memoryOffset; - if (in->pNext) - FIXME("Unexpected pNext\n"); -} - #ifdef _WIN64 -static inline const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM_array_win64_to_host(struct conversion_context *ctx, const VkBindTensorMemoryInfoARM *in, uint32_t count) +static const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM_array_win64_to_host(struct conversion_context *ctx, const VkBindTensorMemoryInfoARM *in, uint32_t count) { VkBindTensorMemoryInfoARM *out; unsigned int i; @@ -10653,7 +10640,20 @@ static inline const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM } #endif /* _WIN64 */

-static inline const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkBindTensorMemoryInfoARM32 *in, uint32_t count) +static void convert_VkBindTensorMemoryInfoARM_win32_to_host(const VkBindTensorMemoryInfoARM32 *in, VkBindTensorMemoryInfoARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->tensor = in->tensor; + out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory; + out->memoryOffset = in->memoryOffset; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkBindTensorMemoryInfoARM32 *in, uint32_t count) { VkBindTensorMemoryInfoARM *out; unsigned int i; @@ -10670,7 +10670,7 @@ static inline const VkBindTensorMemoryInfoARM *convert_VkBindTensorMemoryInfoARM }

#ifdef _WIN64 -static inline void convert_VkBindVideoSessionMemoryInfoKHR_win64_to_host(const VkBindVideoSessionMemoryInfoKHR *in, VkBindVideoSessionMemoryInfoKHR *out) +static void convert_VkBindVideoSessionMemoryInfoKHR_win64_to_host(const VkBindVideoSessionMemoryInfoKHR *in, VkBindVideoSessionMemoryInfoKHR *out) { if (!in) return;

@@ -10683,22 +10683,8 @@ static inline void convert_VkBindVideoSessionMemoryInfoKHR_win64_to_host(const V } #endif /* _WIN64 */

-static inline void convert_VkBindVideoSessionMemoryInfoKHR_win32_to_host(const VkBindVideoSessionMemoryInfoKHR32 *in, VkBindVideoSessionMemoryInfoKHR *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->memoryBindIndex = in->memoryBindIndex; - out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory; - out->memoryOffset = in->memoryOffset; - out->memorySize = in->memorySize; - if (in->pNext) - FIXME("Unexpected pNext\n"); -} - #ifdef _WIN64 -static inline const VkBindVideoSessionMemoryInfoKHR *convert_VkBindVideoSessionMemoryInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkBindVideoSessionMemoryInfoKHR *in, uint32_t count) +static const VkBindVideoSessionMemoryInfoKHR *convert_VkBindVideoSessionMemoryInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkBindVideoSessionMemoryInfoKHR *in, uint32_t count) { VkBindVideoSessionMemoryInfoKHR *out; unsigned int i; @@ -10715,7 +10701,21 @@ static inline const VkBindVideoSessionMemoryInfoKHR *convert_VkBindVideoSessionM } #endif /* _WIN64 */

-static inline const VkBindVideoSessionMemoryInfoKHR *convert_VkBindVideoSessionMemoryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkBindVideoSessionMemoryInfoKHR32 *in, uint32_t count) +static void convert_VkBindVideoSessionMemoryInfoKHR_win32_to_host(const VkBindVideoSessionMemoryInfoKHR32 *in, VkBindVideoSessionMemoryInfoKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->memoryBindIndex = in->memoryBindIndex; + out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory; + out->memoryOffset = in->memoryOffset; + out->memorySize = in->memorySize; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static const VkBindVideoSessionMemoryInfoKHR *convert_VkBindVideoSessionMemoryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkBindVideoSessionMemoryInfoKHR32 *in, uint32_t count) { VkBindVideoSessionMemoryInfoKHR *out; unsigned int i; @@ -10731,7 +10731,7 @@ static inline const VkBindVideoSessionMemoryInfoKHR *convert_VkBindVideoSessionM return out; }

-static inline const VkMicromapUsageEXT * const*convert_VkMicromapUsageEXT_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) +static const VkMicromapUsageEXT * const*convert_VkMicromapUsageEXT_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) { VkMicromapUsageEXT **out; unsigned int i; @@ -10747,7 +10747,7 @@ static inline const VkMicromapUsageEXT * const*convert_VkMicromapUsageEXT_pointe return (void *)out; }

-static inline void convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryTrianglesDataKHR32 *in, VkAccelerationStructureGeometryTrianglesDataKHR *out) +static void convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryTrianglesDataKHR32 *in, VkAccelerationStructureGeometryTrianglesDataKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -10804,7 +10804,7 @@ static inline void convert_VkAccelerationStructureGeometryTrianglesDataKHR_win32 } }

-static inline void convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(const VkAccelerationStructureGeometryAabbsDataKHR32 *in, VkAccelerationStructureGeometryAabbsDataKHR *out) +static void convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_host(const VkAccelerationStructureGeometryAabbsDataKHR32 *in, VkAccelerationStructureGeometryAabbsDataKHR *out) { if (!in) return;

@@ -10816,7 +10816,7 @@ static inline void convert_VkAccelerationStructureGeometryAabbsDataKHR_win32_to_ FIXME("Unexpected pNext\n"); }

-static inline void convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(const VkAccelerationStructureGeometryInstancesDataKHR32 *in, VkAccelerationStructureGeometryInstancesDataKHR *out) +static void convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(const VkAccelerationStructureGeometryInstancesDataKHR32 *in, VkAccelerationStructureGeometryInstancesDataKHR *out) { if (!in) return;

@@ -10828,7 +10828,7 @@ static inline void convert_VkAccelerationStructureGeometryInstancesDataKHR_win32 FIXME("Unexpected pNext\n"); }

-static inline void convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryDataKHR32 *in, VkAccelerationStructureGeometryDataKHR *out, VkFlags selector) +static void convert_VkAccelerationStructureGeometryDataKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryDataKHR32 *in, VkAccelerationStructureGeometryDataKHR *out, VkFlags selector) { if (!in) return;

@@ -10840,7 +10840,7 @@ static inline void convert_VkAccelerationStructureGeometryDataKHR_win32_to_host( convert_VkAccelerationStructureGeometryInstancesDataKHR_win32_to_host(&in->instances, &out->instances); }

-static inline void convert_VkAccelerationStructureGeometryKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, VkAccelerationStructureGeometryKHR *out) +static void convert_VkAccelerationStructureGeometryKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, VkAccelerationStructureGeometryKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -10904,7 +10904,7 @@ static inline void convert_VkAccelerationStructureGeometryKHR_win32_to_host(stru } }

-static inline const VkAccelerationStructureGeometryKHR *convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, uint32_t count) +static const VkAccelerationStructureGeometryKHR *convert_VkAccelerationStructureGeometryKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureGeometryKHR32 *in, uint32_t count) { VkAccelerationStructureGeometryKHR *out; unsigned int i; @@ -10920,7 +10920,7 @@ static inline const VkAccelerationStructureGeometryKHR *convert_VkAccelerationSt return out; }

-static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) +static const VkAccelerationStructureGeometryKHR * const*convert_VkAccelerationStructureGeometryKHR_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) { VkAccelerationStructureGeometryKHR **out; unsigned int i; @@ -10942,7 +10942,7 @@ static inline const VkAccelerationStructureGeometryKHR * const*convert_VkAcceler return (void *)out; }

-static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, VkAccelerationStructureBuildGeometryInfoKHR *out) +static void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, VkAccelerationStructureBuildGeometryInfoKHR *out) { if (!in) return;

@@ -10961,7 +10961,7 @@ static inline void convert_VkAccelerationStructureBuildGeometryInfoKHR_win32_to_ FIXME("Unexpected pNext\n"); }

-static inline const VkAccelerationStructureBuildGeometryInfoKHR *convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, uint32_t count) +static const VkAccelerationStructureBuildGeometryInfoKHR *convert_VkAccelerationStructureBuildGeometryInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureBuildGeometryInfoKHR32 *in, uint32_t count) { VkAccelerationStructureBuildGeometryInfoKHR *out; unsigned int i; @@ -10977,7 +10977,7 @@ static inline const VkAccelerationStructureBuildGeometryInfoKHR *convert_VkAccel return out; }

-static inline const VkAccelerationStructureBuildRangeInfoKHR * const*convert_VkAccelerationStructureBuildRangeInfoKHR_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) +static const VkAccelerationStructureBuildRangeInfoKHR * const*convert_VkAccelerationStructureBuildRangeInfoKHR_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) { VkAccelerationStructureBuildRangeInfoKHR **out; unsigned int i; @@ -10993,7 +10993,7 @@ static inline const VkAccelerationStructureBuildRangeInfoKHR * const*convert_VkA return (void *)out; }

-static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, VkMicromapBuildInfoEXT *out) +static void convert_VkMicromapBuildInfoEXT_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, VkMicromapBuildInfoEXT *out) { if (!in) return;

@@ -11014,7 +11014,7 @@ static inline void convert_VkMicromapBuildInfoEXT_win32_to_host(struct conversio FIXME("Unexpected pNext\n"); }

-static inline const VkMicromapBuildInfoEXT *convert_VkMicromapBuildInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, uint32_t count) +static const VkMicromapBuildInfoEXT *convert_VkMicromapBuildInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkMicromapBuildInfoEXT32 *in, uint32_t count) { VkMicromapBuildInfoEXT *out; unsigned int i; @@ -11030,7 +11030,7 @@ static inline const VkMicromapBuildInfoEXT *convert_VkMicromapBuildInfoEXT_array return out; }

-static inline void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(const VkConditionalRenderingBeginInfoEXT32 *in, VkConditionalRenderingBeginInfoEXT *out) +static void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(const VkConditionalRenderingBeginInfoEXT32 *in, VkConditionalRenderingBeginInfoEXT *out) { if (!in) return;

@@ -11043,7 +11043,7 @@ static inline void convert_VkConditionalRenderingBeginInfoEXT_win32_to_host(cons FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDebugUtilsLabelEXT_win32_to_host(const VkDebugUtilsLabelEXT32 *in, VkDebugUtilsLabelEXT *out) +static void convert_VkDebugUtilsLabelEXT_win32_to_host(const VkDebugUtilsLabelEXT32 *in, VkDebugUtilsLabelEXT *out) { if (!in) return;

@@ -11055,7 +11055,7 @@ static inline void convert_VkDebugUtilsLabelEXT_win32_to_host(const VkDebugUtils FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPerTileBeginInfoQCOM_win32_to_host(const VkPerTileBeginInfoQCOM32 *in, VkPerTileBeginInfoQCOM *out) +static void convert_VkPerTileBeginInfoQCOM_win32_to_host(const VkPerTileBeginInfoQCOM32 *in, VkPerTileBeginInfoQCOM *out) { if (!in) return;

@@ -11065,7 +11065,7 @@ static inline void convert_VkPerTileBeginInfoQCOM_win32_to_host(const VkPerTileB FIXME("Unexpected pNext\n"); }

-static inline void convert_VkSampleLocationsInfoEXT_win32_to_host(const VkSampleLocationsInfoEXT32 *in, VkSampleLocationsInfoEXT *out) +static void convert_VkSampleLocationsInfoEXT_win32_to_host(const VkSampleLocationsInfoEXT32 *in, VkSampleLocationsInfoEXT *out) { if (!in) return;

@@ -11079,7 +11079,7 @@ static inline void convert_VkSampleLocationsInfoEXT_win32_to_host(const VkSample FIXME("Unexpected pNext\n"); }

-static inline void convert_VkAttachmentSampleLocationsEXT_win32_to_host(const VkAttachmentSampleLocationsEXT32 *in, VkAttachmentSampleLocationsEXT *out) +static void convert_VkAttachmentSampleLocationsEXT_win32_to_host(const VkAttachmentSampleLocationsEXT32 *in, VkAttachmentSampleLocationsEXT *out) { if (!in) return;

@@ -11087,7 +11087,7 @@ static inline void convert_VkAttachmentSampleLocationsEXT_win32_to_host(const Vk convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo); }

-static inline const VkAttachmentSampleLocationsEXT *convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentSampleLocationsEXT32 *in, uint32_t count) +static const VkAttachmentSampleLocationsEXT *convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentSampleLocationsEXT32 *in, uint32_t count) { VkAttachmentSampleLocationsEXT *out; unsigned int i; @@ -11103,7 +11103,7 @@ static inline const VkAttachmentSampleLocationsEXT *convert_VkAttachmentSampleLo return out; }

-static inline void convert_VkSubpassSampleLocationsEXT_win32_to_host(const VkSubpassSampleLocationsEXT32 *in, VkSubpassSampleLocationsEXT *out) +static void convert_VkSubpassSampleLocationsEXT_win32_to_host(const VkSubpassSampleLocationsEXT32 *in, VkSubpassSampleLocationsEXT *out) { if (!in) return;

@@ -11111,7 +11111,7 @@ static inline void convert_VkSubpassSampleLocationsEXT_win32_to_host(const VkSub convert_VkSampleLocationsInfoEXT_win32_to_host(&in->sampleLocationsInfo, &out->sampleLocationsInfo); }

-static inline const VkSubpassSampleLocationsEXT *convert_VkSubpassSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkSubpassSampleLocationsEXT32 *in, uint32_t count) +static const VkSubpassSampleLocationsEXT *convert_VkSubpassSampleLocationsEXT_array_win32_to_host(struct conversion_context *ctx, const VkSubpassSampleLocationsEXT32 *in, uint32_t count) { VkSubpassSampleLocationsEXT *out; unsigned int i; @@ -11127,7 +11127,7 @@ static inline const VkSubpassSampleLocationsEXT *convert_VkSubpassSampleLocation return out; }

-static inline void convert_VkRenderPassStripeInfoARM_win32_to_host(const VkRenderPassStripeInfoARM32 *in, VkRenderPassStripeInfoARM *out) +static void convert_VkRenderPassStripeInfoARM_win32_to_host(const VkRenderPassStripeInfoARM32 *in, VkRenderPassStripeInfoARM *out) { if (!in) return;

@@ -11138,7 +11138,7 @@ static inline void convert_VkRenderPassStripeInfoARM_win32_to_host(const VkRende FIXME("Unexpected pNext\n"); }

-static inline const VkRenderPassStripeInfoARM *convert_VkRenderPassStripeInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkRenderPassStripeInfoARM32 *in, uint32_t count) +static const VkRenderPassStripeInfoARM *convert_VkRenderPassStripeInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkRenderPassStripeInfoARM32 *in, uint32_t count) { VkRenderPassStripeInfoARM *out; unsigned int i; @@ -11154,7 +11154,7 @@ static inline const VkRenderPassStripeInfoARM *convert_VkRenderPassStripeInfoARM return out; }

-static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassBeginInfo32 *in, VkRenderPassBeginInfo *out) +static void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassBeginInfo32 *in, VkRenderPassBeginInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -11254,7 +11254,7 @@ static inline void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion } }

-static inline void convert_VkSubpassBeginInfo_win32_to_host(const VkSubpassBeginInfo32 *in, VkSubpassBeginInfo *out) +static void convert_VkSubpassBeginInfo_win32_to_host(const VkSubpassBeginInfo32 *in, VkSubpassBeginInfo *out) { if (!in) return;

@@ -11265,7 +11265,7 @@ static inline void convert_VkSubpassBeginInfo_win32_to_host(const VkSubpassBegin FIXME("Unexpected pNext\n"); }

-static inline void convert_VkRenderingAttachmentInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, VkRenderingAttachmentInfo *out) +static void convert_VkRenderingAttachmentInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, VkRenderingAttachmentInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -11305,7 +11305,7 @@ static inline void convert_VkRenderingAttachmentInfo_win32_to_host(struct conver } }

-static inline const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo_array_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, uint32_t count) +static const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo_array_win32_to_host(struct conversion_context *ctx, const VkRenderingAttachmentInfo32 *in, uint32_t count) { VkRenderingAttachmentInfo *out; unsigned int i; @@ -11321,7 +11321,7 @@ static inline const VkRenderingAttachmentInfo *convert_VkRenderingAttachmentInfo return out; }

-static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingInfo32 *in, VkRenderingInfo *out) +static void convert_VkRenderingInfo_win32_to_host(struct conversion_context *ctx, const VkRenderingInfo32 *in, VkRenderingInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -11447,80 +11447,37 @@ static inline void convert_VkRenderingInfo_win32_to_host(struct conversion_conte } }

-static inline void convert_VkVideoEncodeRateControlLayerInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeRateControlLayerInfoKHR32 *in, VkVideoEncodeRateControlLayerInfoKHR *out) +static void convert_VkVideoPictureResourceInfoKHR_win32_to_host(const VkVideoPictureResourceInfoKHR32 *in, VkVideoPictureResourceInfoKHR *out) { - const VkBaseInStructure32 *in_header; - VkBaseOutStructure *out_header = (void *)out; - if (!in) return;

out->sType = in->sType; out->pNext = NULL; - out->averageBitrate = in->averageBitrate; - out->maxBitrate = in->maxBitrate; - out->frameRateNumerator = in->frameRateNumerator; - out->frameRateDenominator = in->frameRateDenominator; + out->codedOffset = in->codedOffset; + out->codedExtent = in->codedExtent; + out->baseArrayLayer = in->baseArrayLayer; + out->imageViewBinding = in->imageViewBinding; + if (in->pNext) + FIXME("Unexpected pNext\n"); +}

- for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) +static const VkVideoPictureResourceInfoKHR *convert_VkVideoPictureResourceInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoPictureResourceInfoKHR32 *in, uint32_t count) +{ + VkVideoPictureResourceInfoKHR *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) { - switch (in_header->sType) - { - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: - { - VkVideoEncodeH264RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeH264RateControlLayerInfoKHR32 *in_ext = (const VkVideoEncodeH264RateControlLayerInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR; - out_ext->pNext = NULL; - out_ext->useMinQp = in_ext->useMinQp; - out_ext->minQp = in_ext->minQp; - out_ext->useMaxQp = in_ext->useMaxQp; - out_ext->maxQp = in_ext->maxQp; - out_ext->useMaxFrameSize = in_ext->useMaxFrameSize; - out_ext->maxFrameSize = in_ext->maxFrameSize; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: - { - VkVideoEncodeAV1RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeAV1RateControlLayerInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlLayerInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; - out_ext->pNext = NULL; - out_ext->useMinQIndex = in_ext->useMinQIndex; - out_ext->minQIndex = in_ext->minQIndex; - out_ext->useMaxQIndex = in_ext->useMaxQIndex; - out_ext->maxQIndex = in_ext->maxQIndex; - out_ext->useMaxFrameSize = in_ext->useMaxFrameSize; - out_ext->maxFrameSize = in_ext->maxFrameSize; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - default: - FIXME("Unhandled sType %u.\n", in_header->sType); - break; - } - } -} - -static inline const VkVideoEncodeRateControlLayerInfoKHR *convert_VkVideoEncodeRateControlLayerInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeRateControlLayerInfoKHR32 *in, uint32_t count) -{ - VkVideoEncodeRateControlLayerInfoKHR *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkVideoEncodeRateControlLayerInfoKHR_win32_to_host(ctx, &in[i], &out[i]); + convert_VkVideoPictureResourceInfoKHR_win32_to_host(&in[i], &out[i]); }

return out; }

-static inline void convert_StdVideoEncodeAV1ReferenceInfo_win32_to_host(const StdVideoEncodeAV1ReferenceInfo32 *in, StdVideoEncodeAV1ReferenceInfo *out) +static void convert_StdVideoEncodeAV1ReferenceInfo_win32_to_host(const StdVideoEncodeAV1ReferenceInfo32 *in, StdVideoEncodeAV1ReferenceInfo *out) { if (!in) return;

@@ -11532,7 +11489,7 @@ static inline void convert_StdVideoEncodeAV1ReferenceInfo_win32_to_host(const St out->pExtensionHeader = UlongToPtr(in->pExtensionHeader); }

-static inline const StdVideoEncodeAV1ReferenceInfo *convert_StdVideoEncodeAV1ReferenceInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1ReferenceInfo32 *in, uint32_t count) +static const StdVideoEncodeAV1ReferenceInfo *convert_StdVideoEncodeAV1ReferenceInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1ReferenceInfo32 *in, uint32_t count) { StdVideoEncodeAV1ReferenceInfo *out; unsigned int i; @@ -11548,37 +11505,7 @@ static inline const StdVideoEncodeAV1ReferenceInfo *convert_StdVideoEncodeAV1Ref return out; }

-static inline void convert_VkVideoPictureResourceInfoKHR_win32_to_host(const VkVideoPictureResourceInfoKHR32 *in, VkVideoPictureResourceInfoKHR *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->codedOffset = in->codedOffset; - out->codedExtent = in->codedExtent; - out->baseArrayLayer = in->baseArrayLayer; - out->imageViewBinding = in->imageViewBinding; - if (in->pNext) - FIXME("Unexpected pNext\n"); -} - -static inline const VkVideoPictureResourceInfoKHR *convert_VkVideoPictureResourceInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoPictureResourceInfoKHR32 *in, uint32_t count) -{ - VkVideoPictureResourceInfoKHR *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkVideoPictureResourceInfoKHR_win32_to_host(&in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoReferenceSlotInfoKHR32 *in, VkVideoReferenceSlotInfoKHR *out) +static void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoReferenceSlotInfoKHR32 *in, VkVideoReferenceSlotInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -11656,7 +11583,7 @@ static inline void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conv } }

-static inline const VkVideoReferenceSlotInfoKHR *convert_VkVideoReferenceSlotInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoReferenceSlotInfoKHR32 *in, uint32_t count) +static const VkVideoReferenceSlotInfoKHR *convert_VkVideoReferenceSlotInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoReferenceSlotInfoKHR32 *in, uint32_t count) { VkVideoReferenceSlotInfoKHR *out; unsigned int i; @@ -11672,7 +11599,80 @@ static inline const VkVideoReferenceSlotInfoKHR *convert_VkVideoReferenceSlotInf return out; }

-static inline void convert_VkVideoBeginCodingInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoBeginCodingInfoKHR32 *in, VkVideoBeginCodingInfoKHR *out) +static void convert_VkVideoEncodeRateControlLayerInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeRateControlLayerInfoKHR32 *in, VkVideoEncodeRateControlLayerInfoKHR *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->averageBitrate = in->averageBitrate; + out->maxBitrate = in->maxBitrate; + out->frameRateNumerator = in->frameRateNumerator; + out->frameRateDenominator = in->frameRateDenominator; + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + { + VkVideoEncodeH264RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeH264RateControlLayerInfoKHR32 *in_ext = (const VkVideoEncodeH264RateControlLayerInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR; + out_ext->pNext = NULL; + out_ext->useMinQp = in_ext->useMinQp; + out_ext->minQp = in_ext->minQp; + out_ext->useMaxQp = in_ext->useMaxQp; + out_ext->maxQp = in_ext->maxQp; + out_ext->useMaxFrameSize = in_ext->useMaxFrameSize; + out_ext->maxFrameSize = in_ext->maxFrameSize; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: + { + VkVideoEncodeAV1RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1RateControlLayerInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlLayerInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR; + out_ext->pNext = NULL; + out_ext->useMinQIndex = in_ext->useMinQIndex; + out_ext->minQIndex = in_ext->minQIndex; + out_ext->useMaxQIndex = in_ext->useMaxQIndex; + out_ext->maxQIndex = in_ext->maxQIndex; + out_ext->useMaxFrameSize = in_ext->useMaxFrameSize; + out_ext->maxFrameSize = in_ext->maxFrameSize; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} + +static const VkVideoEncodeRateControlLayerInfoKHR *convert_VkVideoEncodeRateControlLayerInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeRateControlLayerInfoKHR32 *in, uint32_t count) +{ + VkVideoEncodeRateControlLayerInfoKHR *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkVideoEncodeRateControlLayerInfoKHR_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkVideoBeginCodingInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoBeginCodingInfoKHR32 *in, VkVideoBeginCodingInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -11772,7 +11772,7 @@ static inline void convert_VkVideoBeginCodingInfoKHR_win32_to_host(struct conver } }

-static inline void convert_VkBindDescriptorBufferEmbeddedSamplersInfoEXT_win32_to_host(struct conversion_context *ctx, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT32 *in, VkBindDescriptorBufferEmbeddedSamplersInfoEXT *out) +static void convert_VkBindDescriptorBufferEmbeddedSamplersInfoEXT_win32_to_host(struct conversion_context *ctx, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT32 *in, VkBindDescriptorBufferEmbeddedSamplersInfoEXT *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -11811,7 +11811,7 @@ static inline void convert_VkBindDescriptorBufferEmbeddedSamplersInfoEXT_win32_t } }

-static inline void convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, VkDescriptorBufferBindingInfoEXT *out) +static void convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, VkDescriptorBufferBindingInfoEXT *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -11856,7 +11856,7 @@ static inline void convert_VkDescriptorBufferBindingInfoEXT_win32_to_host(struct } }

-static inline const VkDescriptorBufferBindingInfoEXT *convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, uint32_t count) +static const VkDescriptorBufferBindingInfoEXT *convert_VkDescriptorBufferBindingInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferBindingInfoEXT32 *in, uint32_t count) { VkDescriptorBufferBindingInfoEXT *out; unsigned int i; @@ -11872,7 +11872,7 @@ static inline const VkDescriptorBufferBindingInfoEXT *convert_VkDescriptorBuffer return out; }

-static inline void convert_VkBindDescriptorSetsInfo_win32_to_host(struct conversion_context *ctx, const VkBindDescriptorSetsInfo32 *in, VkBindDescriptorSetsInfo *out) +static void convert_VkBindDescriptorSetsInfo_win32_to_host(struct conversion_context *ctx, const VkBindDescriptorSetsInfo32 *in, VkBindDescriptorSetsInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -11916,7 +11916,7 @@ static inline void convert_VkBindDescriptorSetsInfo_win32_to_host(struct convers }

#ifdef _WIN64 -static inline void convert_VkTileMemoryBindInfoQCOM_win64_to_host(const VkTileMemoryBindInfoQCOM *in, VkTileMemoryBindInfoQCOM *out) +static void convert_VkTileMemoryBindInfoQCOM_win64_to_host(const VkTileMemoryBindInfoQCOM *in, VkTileMemoryBindInfoQCOM *out) { if (!in) return;

@@ -11926,7 +11926,7 @@ static inline void convert_VkTileMemoryBindInfoQCOM_win64_to_host(const VkTileMe } #endif /* _WIN64 */

-static inline void convert_VkTileMemoryBindInfoQCOM_win32_to_host(const VkTileMemoryBindInfoQCOM32 *in, VkTileMemoryBindInfoQCOM *out) +static void convert_VkTileMemoryBindInfoQCOM_win32_to_host(const VkTileMemoryBindInfoQCOM32 *in, VkTileMemoryBindInfoQCOM *out) { if (!in) return;

@@ -11937,7 +11937,7 @@ static inline void convert_VkTileMemoryBindInfoQCOM_win32_to_host(const VkTileMe FIXME("Unexpected pNext\n"); }

-static inline void convert_VkImageBlit2_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, VkImageBlit2 *out) +static void convert_VkImageBlit2_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, VkImageBlit2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -11973,7 +11973,7 @@ static inline void convert_VkImageBlit2_win32_to_host(struct conversion_context } }

-static inline const VkImageBlit2 *convert_VkImageBlit2_array_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, uint32_t count) +static const VkImageBlit2 *convert_VkImageBlit2_array_win32_to_host(struct conversion_context *ctx, const VkImageBlit232 *in, uint32_t count) { VkImageBlit2 *out; unsigned int i; @@ -11989,7 +11989,7 @@ static inline const VkImageBlit2 *convert_VkImageBlit2_array_win32_to_host(struc return out; }

-static inline void convert_VkBlitImageInfo2_win32_to_host(struct conversion_context *ctx, const VkBlitImageInfo232 *in, VkBlitImageInfo2 *out) +static void convert_VkBlitImageInfo2_win32_to_host(struct conversion_context *ctx, const VkBlitImageInfo232 *in, VkBlitImageInfo2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -12028,7 +12028,7 @@ static inline void convert_VkBlitImageInfo2_win32_to_host(struct conversion_cont } }

-static inline void convert_VkGeometryTrianglesNV_win32_to_host(const VkGeometryTrianglesNV32 *in, VkGeometryTrianglesNV *out) +static void convert_VkGeometryTrianglesNV_win32_to_host(const VkGeometryTrianglesNV32 *in, VkGeometryTrianglesNV *out) { if (!in) return;

@@ -12049,7 +12049,7 @@ static inline void convert_VkGeometryTrianglesNV_win32_to_host(const VkGeometryT FIXME("Unexpected pNext\n"); }

-static inline void convert_VkGeometryAABBNV_win32_to_host(const VkGeometryAABBNV32 *in, VkGeometryAABBNV *out) +static void convert_VkGeometryAABBNV_win32_to_host(const VkGeometryAABBNV32 *in, VkGeometryAABBNV *out) { if (!in) return;

@@ -12063,7 +12063,7 @@ static inline void convert_VkGeometryAABBNV_win32_to_host(const VkGeometryAABBNV FIXME("Unexpected pNext\n"); }

-static inline void convert_VkGeometryDataNV_win32_to_host(const VkGeometryDataNV32 *in, VkGeometryDataNV *out) +static void convert_VkGeometryDataNV_win32_to_host(const VkGeometryDataNV32 *in, VkGeometryDataNV *out) { if (!in) return;

@@ -12071,7 +12071,7 @@ static inline void convert_VkGeometryDataNV_win32_to_host(const VkGeometryDataNV convert_VkGeometryAABBNV_win32_to_host(&in->aabbs, &out->aabbs); }

-static inline void convert_VkGeometryNV_win32_to_host(const VkGeometryNV32 *in, VkGeometryNV *out) +static void convert_VkGeometryNV_win32_to_host(const VkGeometryNV32 *in, VkGeometryNV *out) { if (!in) return;

@@ -12084,7 +12084,7 @@ static inline void convert_VkGeometryNV_win32_to_host(const VkGeometryNV32 *in, FIXME("Unexpected pNext\n"); }

-static inline const VkGeometryNV *convert_VkGeometryNV_array_win32_to_host(struct conversion_context *ctx, const VkGeometryNV32 *in, uint32_t count) +static const VkGeometryNV *convert_VkGeometryNV_array_win32_to_host(struct conversion_context *ctx, const VkGeometryNV32 *in, uint32_t count) { VkGeometryNV *out; unsigned int i; @@ -12100,7 +12100,7 @@ static inline const VkGeometryNV *convert_VkGeometryNV_array_win32_to_host(struc return out; }

-static inline void convert_VkAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureInfoNV32 *in, VkAccelerationStructureInfoNV *out) +static void convert_VkAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureInfoNV32 *in, VkAccelerationStructureInfoNV *out) { if (!in) return;

@@ -12115,7 +12115,7 @@ static inline void convert_VkAccelerationStructureInfoNV_win32_to_host(struct co FIXME("Unexpected pNext\n"); }

-static inline const uint32_t * const*convert_uint32_t_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) +static const uint32_t * const*convert_uint32_t_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) { uint32_t **out; unsigned int i; @@ -12131,7 +12131,7 @@ static inline const uint32_t * const*convert_uint32_t_array_win32_to_host(struct return (void *)out; }

-static inline void convert_uint32_t_array_host_to_win32(const uint32_t * const*in, PTR32 *out, uint32_t count) +static void convert_uint32_t_array_host_to_win32(const uint32_t * const*in, PTR32 *out, uint32_t count) { unsigned int i;

@@ -12143,7 +12143,7 @@ static inline void convert_uint32_t_array_host_to_win32(const uint32_t * const*i } }

-static inline void convert_VkClusterAccelerationStructureClustersBottomLevelInputNV_win32_to_host(const VkClusterAccelerationStructureClustersBottomLevelInputNV32 *in, VkClusterAccelerationStructureClustersBottomLevelInputNV *out) +static void convert_VkClusterAccelerationStructureClustersBottomLevelInputNV_win32_to_host(const VkClusterAccelerationStructureClustersBottomLevelInputNV32 *in, VkClusterAccelerationStructureClustersBottomLevelInputNV *out) { if (!in) return;

@@ -12155,7 +12155,7 @@ static inline void convert_VkClusterAccelerationStructureClustersBottomLevelInpu FIXME("Unexpected pNext\n"); }

-static inline VkClusterAccelerationStructureClustersBottomLevelInputNV *convert_VkClusterAccelerationStructureClustersBottomLevelInputNV_array_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureClustersBottomLevelInputNV32 *in, uint32_t count) +static VkClusterAccelerationStructureClustersBottomLevelInputNV *convert_VkClusterAccelerationStructureClustersBottomLevelInputNV_array_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureClustersBottomLevelInputNV32 *in, uint32_t count) { VkClusterAccelerationStructureClustersBottomLevelInputNV *out; unsigned int i; @@ -12171,7 +12171,7 @@ static inline VkClusterAccelerationStructureClustersBottomLevelInputNV *convert_ return out; }

-static inline void convert_VkClusterAccelerationStructureTriangleClusterInputNV_win32_to_host(const VkClusterAccelerationStructureTriangleClusterInputNV32 *in, VkClusterAccelerationStructureTriangleClusterInputNV *out) +static void convert_VkClusterAccelerationStructureTriangleClusterInputNV_win32_to_host(const VkClusterAccelerationStructureTriangleClusterInputNV32 *in, VkClusterAccelerationStructureTriangleClusterInputNV *out) { if (!in) return;

@@ -12189,7 +12189,7 @@ static inline void convert_VkClusterAccelerationStructureTriangleClusterInputNV_ FIXME("Unexpected pNext\n"); }

-static inline VkClusterAccelerationStructureTriangleClusterInputNV *convert_VkClusterAccelerationStructureTriangleClusterInputNV_array_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureTriangleClusterInputNV32 *in, uint32_t count) +static VkClusterAccelerationStructureTriangleClusterInputNV *convert_VkClusterAccelerationStructureTriangleClusterInputNV_array_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureTriangleClusterInputNV32 *in, uint32_t count) { VkClusterAccelerationStructureTriangleClusterInputNV *out; unsigned int i; @@ -12205,7 +12205,7 @@ static inline VkClusterAccelerationStructureTriangleClusterInputNV *convert_VkCl return out; }

-static inline void convert_VkClusterAccelerationStructureMoveObjectsInputNV_win32_to_host(const VkClusterAccelerationStructureMoveObjectsInputNV32 *in, VkClusterAccelerationStructureMoveObjectsInputNV *out) +static void convert_VkClusterAccelerationStructureMoveObjectsInputNV_win32_to_host(const VkClusterAccelerationStructureMoveObjectsInputNV32 *in, VkClusterAccelerationStructureMoveObjectsInputNV *out) { if (!in) return;

@@ -12218,7 +12218,7 @@ static inline void convert_VkClusterAccelerationStructureMoveObjectsInputNV_win3 FIXME("Unexpected pNext\n"); }

-static inline VkClusterAccelerationStructureMoveObjectsInputNV *convert_VkClusterAccelerationStructureMoveObjectsInputNV_array_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureMoveObjectsInputNV32 *in, uint32_t count) +static VkClusterAccelerationStructureMoveObjectsInputNV *convert_VkClusterAccelerationStructureMoveObjectsInputNV_array_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureMoveObjectsInputNV32 *in, uint32_t count) { VkClusterAccelerationStructureMoveObjectsInputNV *out; unsigned int i; @@ -12234,7 +12234,7 @@ static inline VkClusterAccelerationStructureMoveObjectsInputNV *convert_VkCluste return out; }

-static inline void convert_VkClusterAccelerationStructureOpInputNV_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureOpInputNV32 *in, VkClusterAccelerationStructureOpInputNV *out, VkFlags selector) +static void convert_VkClusterAccelerationStructureOpInputNV_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureOpInputNV32 *in, VkClusterAccelerationStructureOpInputNV *out, VkFlags selector) { if (!in) return;

@@ -12246,7 +12246,7 @@ static inline void convert_VkClusterAccelerationStructureOpInputNV_win32_to_host out->pMoveObjects = convert_VkClusterAccelerationStructureMoveObjectsInputNV_array_win32_to_host(ctx, (VkClusterAccelerationStructureMoveObjectsInputNV32 *)UlongToPtr(in->pMoveObjects), 1); }

-static inline void convert_VkClusterAccelerationStructureInputInfoNV_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureInputInfoNV32 *in, VkClusterAccelerationStructureInputInfoNV *out) +static void convert_VkClusterAccelerationStructureInputInfoNV_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureInputInfoNV32 *in, VkClusterAccelerationStructureInputInfoNV *out) { if (!in) return;

@@ -12261,7 +12261,7 @@ static inline void convert_VkClusterAccelerationStructureInputInfoNV_win32_to_ho FIXME("Unexpected pNext\n"); }

-static inline void convert_VkStridedDeviceAddressRegionKHR_win32_to_host(const VkStridedDeviceAddressRegionKHR32 *in, VkStridedDeviceAddressRegionKHR *out) +static void convert_VkStridedDeviceAddressRegionKHR_win32_to_host(const VkStridedDeviceAddressRegionKHR32 *in, VkStridedDeviceAddressRegionKHR *out) { if (!in) return;

@@ -12270,7 +12270,7 @@ static inline void convert_VkStridedDeviceAddressRegionKHR_win32_to_host(const V out->size = in->size; }

-static inline void convert_VkClusterAccelerationStructureCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureCommandsInfoNV32 *in, VkClusterAccelerationStructureCommandsInfoNV *out) +static void convert_VkClusterAccelerationStructureCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkClusterAccelerationStructureCommandsInfoNV32 *in, VkClusterAccelerationStructureCommandsInfoNV *out) { if (!in) return;

@@ -12288,7 +12288,7 @@ static inline void convert_VkClusterAccelerationStructureCommandsInfoNV_win32_to FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPartitionedAccelerationStructureInstancesInputNV_win32_to_host(struct conversion_context *ctx, const VkPartitionedAccelerationStructureInstancesInputNV32 *in, VkPartitionedAccelerationStructureInstancesInputNV *out) +static void convert_VkPartitionedAccelerationStructureInstancesInputNV_win32_to_host(struct conversion_context *ctx, const VkPartitionedAccelerationStructureInstancesInputNV32 *in, VkPartitionedAccelerationStructureInstancesInputNV *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -12325,13 +12325,7 @@ static inline void convert_VkPartitionedAccelerationStructureInstancesInputNV_wi } }

-static inline void convert_VkPartitionedAccelerationStructureInstancesInputNV_host_to_win32(const VkPartitionedAccelerationStructureInstancesInputNV *in, const VkPartitionedAccelerationStructureInstancesInputNV32 *out) -{ - if (!in) return; - -} - -static inline void convert_VkBuildPartitionedAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkBuildPartitionedAccelerationStructureInfoNV32 *in, VkBuildPartitionedAccelerationStructureInfoNV *out) +static void convert_VkBuildPartitionedAccelerationStructureInfoNV_win32_to_host(struct conversion_context *ctx, const VkBuildPartitionedAccelerationStructureInfoNV32 *in, VkBuildPartitionedAccelerationStructureInfoNV *out) { if (!in) return;

@@ -12347,7 +12341,7 @@ static inline void convert_VkBuildPartitionedAccelerationStructureInfoNV_win32_t FIXME("Unexpected pNext\n"); }

-static inline void convert_VkVideoCodingControlInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoCodingControlInfoKHR32 *in, VkVideoCodingControlInfoKHR *out) +static void convert_VkVideoCodingControlInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoCodingControlInfoKHR32 *in, VkVideoCodingControlInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -12426,7 +12420,7 @@ static inline void convert_VkVideoCodingControlInfoKHR_win32_to_host(struct conv } }

-static inline void convert_VkConvertCooperativeVectorMatrixInfoNV_win32_to_host(const VkConvertCooperativeVectorMatrixInfoNV32 *in, VkConvertCooperativeVectorMatrixInfoNV *out) +static void convert_VkConvertCooperativeVectorMatrixInfoNV_win32_to_host(const VkConvertCooperativeVectorMatrixInfoNV32 *in, VkConvertCooperativeVectorMatrixInfoNV *out) { if (!in) return;

@@ -12448,7 +12442,7 @@ static inline void convert_VkConvertCooperativeVectorMatrixInfoNV_win32_to_host( FIXME("Unexpected pNext\n"); }

-static inline const VkConvertCooperativeVectorMatrixInfoNV *convert_VkConvertCooperativeVectorMatrixInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkConvertCooperativeVectorMatrixInfoNV32 *in, uint32_t count) +static const VkConvertCooperativeVectorMatrixInfoNV *convert_VkConvertCooperativeVectorMatrixInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkConvertCooperativeVectorMatrixInfoNV32 *in, uint32_t count) { VkConvertCooperativeVectorMatrixInfoNV *out; unsigned int i; @@ -12464,7 +12458,7 @@ static inline const VkConvertCooperativeVectorMatrixInfoNV *convert_VkConvertCoo return out; }

-static inline void convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(const VkCopyAccelerationStructureInfoKHR32 *in, VkCopyAccelerationStructureInfoKHR *out) +static void convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(const VkCopyAccelerationStructureInfoKHR32 *in, VkCopyAccelerationStructureInfoKHR *out) { if (!in) return;

@@ -12477,7 +12471,7 @@ static inline void convert_VkCopyAccelerationStructureInfoKHR_win32_to_host(cons FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(const VkCopyAccelerationStructureToMemoryInfoKHR32 *in, VkCopyAccelerationStructureToMemoryInfoKHR *out) +static void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_host(const VkCopyAccelerationStructureToMemoryInfoKHR32 *in, VkCopyAccelerationStructureToMemoryInfoKHR *out) { if (!in) return;

@@ -12490,7 +12484,7 @@ static inline void convert_VkCopyAccelerationStructureToMemoryInfoKHR_win32_to_h FIXME("Unexpected pNext\n"); }

-static inline void convert_VkBufferCopy_win32_to_host(const VkBufferCopy32 *in, VkBufferCopy *out) +static void convert_VkBufferCopy_win32_to_host(const VkBufferCopy32 *in, VkBufferCopy *out) { if (!in) return;

@@ -12499,7 +12493,7 @@ static inline void convert_VkBufferCopy_win32_to_host(const VkBufferCopy32 *in, out->size = in->size; }

-static inline const VkBufferCopy *convert_VkBufferCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy32 *in, uint32_t count) +static const VkBufferCopy *convert_VkBufferCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy32 *in, uint32_t count) { VkBufferCopy *out; unsigned int i; @@ -12515,7 +12509,7 @@ static inline const VkBufferCopy *convert_VkBufferCopy_array_win32_to_host(struc return out; }

-static inline void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy232 *in, VkBufferCopy2 *out) +static void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy232 *in, VkBufferCopy2 *out) { if (!in) return;

@@ -12528,7 +12522,7 @@ static inline void convert_VkBufferCopy2_win32_to_host(const VkBufferCopy232 *in FIXME("Unexpected pNext\n"); }

-static inline const VkBufferCopy2 *convert_VkBufferCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy232 *in, uint32_t count) +static const VkBufferCopy2 *convert_VkBufferCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferCopy232 *in, uint32_t count) { VkBufferCopy2 *out; unsigned int i; @@ -12544,7 +12538,7 @@ static inline const VkBufferCopy2 *convert_VkBufferCopy2_array_win32_to_host(str return out; }

-static inline void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferInfo232 *in, VkCopyBufferInfo2 *out) +static void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferInfo232 *in, VkCopyBufferInfo2 *out) { if (!in) return;

@@ -12558,7 +12552,7 @@ static inline void convert_VkCopyBufferInfo2_win32_to_host(struct conversion_con FIXME("Unexpected pNext\n"); }

-static inline void convert_VkBufferImageCopy_win32_to_host(const VkBufferImageCopy32 *in, VkBufferImageCopy *out) +static void convert_VkBufferImageCopy_win32_to_host(const VkBufferImageCopy32 *in, VkBufferImageCopy *out) { if (!in) return;

@@ -12570,7 +12564,7 @@ static inline void convert_VkBufferImageCopy_win32_to_host(const VkBufferImageCo out->imageExtent = in->imageExtent; }

-static inline const VkBufferImageCopy *convert_VkBufferImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy32 *in, uint32_t count) +static const VkBufferImageCopy *convert_VkBufferImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy32 *in, uint32_t count) { VkBufferImageCopy *out; unsigned int i; @@ -12586,7 +12580,7 @@ static inline const VkBufferImageCopy *convert_VkBufferImageCopy_array_win32_to_ return out; }

-static inline void convert_VkBufferImageCopy2_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, VkBufferImageCopy2 *out) +static void convert_VkBufferImageCopy2_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, VkBufferImageCopy2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -12624,7 +12618,7 @@ static inline void convert_VkBufferImageCopy2_win32_to_host(struct conversion_co } }

-static inline const VkBufferImageCopy2 *convert_VkBufferImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, uint32_t count) +static const VkBufferImageCopy2 *convert_VkBufferImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkBufferImageCopy232 *in, uint32_t count) { VkBufferImageCopy2 *out; unsigned int i; @@ -12640,7 +12634,7 @@ static inline const VkBufferImageCopy2 *convert_VkBufferImageCopy2_array_win32_t return out; }

-static inline void convert_VkCopyBufferToImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferToImageInfo232 *in, VkCopyBufferToImageInfo2 *out) +static void convert_VkCopyBufferToImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyBufferToImageInfo232 *in, VkCopyBufferToImageInfo2 *out) { if (!in) return;

@@ -12655,7 +12649,7 @@ static inline void convert_VkCopyBufferToImageInfo2_win32_to_host(struct convers FIXME("Unexpected pNext\n"); }

-static inline void convert_VkImageCopy2_win32_to_host(const VkImageCopy232 *in, VkImageCopy2 *out) +static void convert_VkImageCopy2_win32_to_host(const VkImageCopy232 *in, VkImageCopy2 *out) { if (!in) return;

@@ -12670,7 +12664,7 @@ static inline void convert_VkImageCopy2_win32_to_host(const VkImageCopy232 *in, FIXME("Unexpected pNext\n"); }

-static inline const VkImageCopy2 *convert_VkImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkImageCopy232 *in, uint32_t count) +static const VkImageCopy2 *convert_VkImageCopy2_array_win32_to_host(struct conversion_context *ctx, const VkImageCopy232 *in, uint32_t count) { VkImageCopy2 *out; unsigned int i; @@ -12686,7 +12680,7 @@ static inline const VkImageCopy2 *convert_VkImageCopy2_array_win32_to_host(struc return out; }

-static inline void convert_VkCopyImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageInfo232 *in, VkCopyImageInfo2 *out) +static void convert_VkCopyImageInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageInfo232 *in, VkCopyImageInfo2 *out) { if (!in) return;

@@ -12702,7 +12696,7 @@ static inline void convert_VkCopyImageInfo2_win32_to_host(struct conversion_cont FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCopyImageToBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageToBufferInfo232 *in, VkCopyImageToBufferInfo2 *out) +static void convert_VkCopyImageToBufferInfo2_win32_to_host(struct conversion_context *ctx, const VkCopyImageToBufferInfo232 *in, VkCopyImageToBufferInfo2 *out) { if (!in) return;

@@ -12717,7 +12711,7 @@ static inline void convert_VkCopyImageToBufferInfo2_win32_to_host(struct convers FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(const VkCopyMemoryToAccelerationStructureInfoKHR32 *in, VkCopyMemoryToAccelerationStructureInfoKHR *out) +static void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_host(const VkCopyMemoryToAccelerationStructureInfoKHR32 *in, VkCopyMemoryToAccelerationStructureInfoKHR *out) { if (!in) return;

@@ -12730,7 +12724,7 @@ static inline void convert_VkCopyMemoryToAccelerationStructureInfoKHR_win32_to_h FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkCopyMemoryToMicromapInfoEXT32 *in, VkCopyMemoryToMicromapInfoEXT *out) +static void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkCopyMemoryToMicromapInfoEXT32 *in, VkCopyMemoryToMicromapInfoEXT *out) { if (!in) return;

@@ -12743,7 +12737,7 @@ static inline void convert_VkCopyMemoryToMicromapInfoEXT_win32_to_host(const VkC FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicromapInfoEXT32 *in, VkCopyMicromapInfoEXT *out) +static void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicromapInfoEXT32 *in, VkCopyMicromapInfoEXT *out) { if (!in) return;

@@ -12756,7 +12750,7 @@ static inline void convert_VkCopyMicromapInfoEXT_win32_to_host(const VkCopyMicro FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkCopyMicromapToMemoryInfoEXT32 *in, VkCopyMicromapToMemoryInfoEXT *out) +static void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkCopyMicromapToMemoryInfoEXT32 *in, VkCopyMicromapToMemoryInfoEXT *out) { if (!in) return;

@@ -12769,7 +12763,7 @@ static inline void convert_VkCopyMicromapToMemoryInfoEXT_win32_to_host(const VkC FIXME("Unexpected pNext\n"); }

-static inline void convert_VkTensorCopyARM_win32_to_host(const VkTensorCopyARM32 *in, VkTensorCopyARM *out) +static void convert_VkTensorCopyARM_win32_to_host(const VkTensorCopyARM32 *in, VkTensorCopyARM *out) { if (!in) return;

@@ -12783,7 +12777,7 @@ static inline void convert_VkTensorCopyARM_win32_to_host(const VkTensorCopyARM32 FIXME("Unexpected pNext\n"); }

-static inline const VkTensorCopyARM *convert_VkTensorCopyARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorCopyARM32 *in, uint32_t count) +static const VkTensorCopyARM *convert_VkTensorCopyARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorCopyARM32 *in, uint32_t count) { VkTensorCopyARM *out; unsigned int i; @@ -12799,7 +12793,7 @@ static inline const VkTensorCopyARM *convert_VkTensorCopyARM_array_win32_to_host return out; }

-static inline void convert_VkCopyTensorInfoARM_win32_to_host(struct conversion_context *ctx, const VkCopyTensorInfoARM32 *in, VkCopyTensorInfoARM *out) +static void convert_VkCopyTensorInfoARM_win32_to_host(struct conversion_context *ctx, const VkCopyTensorInfoARM32 *in, VkCopyTensorInfoARM *out) { if (!in) return;

@@ -12813,7 +12807,7 @@ static inline void convert_VkCopyTensorInfoARM_win32_to_host(struct conversion_c FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoNVX32 *in, VkCuLaunchInfoNVX *out) +static void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoNVX32 *in, VkCuLaunchInfoNVX *out) { if (!in) return;

@@ -12835,7 +12829,7 @@ static inline void convert_VkCuLaunchInfoNVX_win32_to_host(const VkCuLaunchInfoN FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebugMarkerMarkerInfoEXT32 *in, VkDebugMarkerMarkerInfoEXT *out) +static void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebugMarkerMarkerInfoEXT32 *in, VkDebugMarkerMarkerInfoEXT *out) { if (!in) return;

@@ -12847,7 +12841,7 @@ static inline void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebu FIXME("Unexpected pNext\n"); }

-static inline void convert_StdVideoDecodeVP9PictureInfo_win32_to_host(const StdVideoDecodeVP9PictureInfo32 *in, StdVideoDecodeVP9PictureInfo *out) +static void convert_StdVideoDecodeVP9PictureInfo_win32_to_host(const StdVideoDecodeVP9PictureInfo32 *in, StdVideoDecodeVP9PictureInfo *out) { if (!in) return;

@@ -12871,7 +12865,7 @@ static inline void convert_StdVideoDecodeVP9PictureInfo_win32_to_host(const StdV out->pSegmentation = UlongToPtr(in->pSegmentation); }

-static inline const StdVideoDecodeVP9PictureInfo *convert_StdVideoDecodeVP9PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeVP9PictureInfo32 *in, uint32_t count) +static const StdVideoDecodeVP9PictureInfo *convert_StdVideoDecodeVP9PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeVP9PictureInfo32 *in, uint32_t count) { StdVideoDecodeVP9PictureInfo *out; unsigned int i; @@ -12887,7 +12881,7 @@ static inline const StdVideoDecodeVP9PictureInfo *convert_StdVideoDecodeVP9Pictu return out; }

-static inline void convert_StdVideoAV1TileInfo_win32_to_host(const StdVideoAV1TileInfo32 *in, StdVideoAV1TileInfo *out) +static void convert_StdVideoAV1TileInfo_win32_to_host(const StdVideoAV1TileInfo32 *in, StdVideoAV1TileInfo *out) { if (!in) return;

@@ -12903,7 +12897,7 @@ static inline void convert_StdVideoAV1TileInfo_win32_to_host(const StdVideoAV1Ti out->pHeightInSbsMinus1 = UlongToPtr(in->pHeightInSbsMinus1); }

-static inline const StdVideoAV1TileInfo *convert_StdVideoAV1TileInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoAV1TileInfo32 *in, uint32_t count) +static const StdVideoAV1TileInfo *convert_StdVideoAV1TileInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoAV1TileInfo32 *in, uint32_t count) { StdVideoAV1TileInfo *out; unsigned int i; @@ -12919,7 +12913,7 @@ static inline const StdVideoAV1TileInfo *convert_StdVideoAV1TileInfo_array_win32 return out; }

-static inline void convert_StdVideoDecodeAV1PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeAV1PictureInfo32 *in, StdVideoDecodeAV1PictureInfo *out) +static void convert_StdVideoDecodeAV1PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeAV1PictureInfo32 *in, StdVideoDecodeAV1PictureInfo *out) { if (!in) return;

@@ -12949,7 +12943,7 @@ static inline void convert_StdVideoDecodeAV1PictureInfo_win32_to_host(struct con out->pFilmGrain = UlongToPtr(in->pFilmGrain); }

-static inline const StdVideoDecodeAV1PictureInfo *convert_StdVideoDecodeAV1PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeAV1PictureInfo32 *in, uint32_t count) +static const StdVideoDecodeAV1PictureInfo *convert_StdVideoDecodeAV1PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeAV1PictureInfo32 *in, uint32_t count) { StdVideoDecodeAV1PictureInfo *out; unsigned int i; @@ -12965,7 +12959,7 @@ static inline const StdVideoDecodeAV1PictureInfo *convert_StdVideoDecodeAV1Pictu return out; }

-static inline void convert_VkVideoDecodeInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeInfoKHR32 *in, VkVideoDecodeInfoKHR *out) +static void convert_VkVideoDecodeInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeInfoKHR32 *in, VkVideoDecodeInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -13051,7 +13045,7 @@ static inline void convert_VkVideoDecodeInfoKHR_win32_to_host(struct conversion_ } }

-static inline void convert_VkDecompressMemoryRegionNV_win32_to_host(const VkDecompressMemoryRegionNV32 *in, VkDecompressMemoryRegionNV *out) +static void convert_VkDecompressMemoryRegionNV_win32_to_host(const VkDecompressMemoryRegionNV32 *in, VkDecompressMemoryRegionNV *out) { if (!in) return;

@@ -13062,7 +13056,7 @@ static inline void convert_VkDecompressMemoryRegionNV_win32_to_host(const VkDeco out->decompressionMethod = in->decompressionMethod; }

-static inline const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegionNV_array_win32_to_host(struct conversion_context *ctx, const VkDecompressMemoryRegionNV32 *in, uint32_t count) +static const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegionNV_array_win32_to_host(struct conversion_context *ctx, const VkDecompressMemoryRegionNV32 *in, uint32_t count) { VkDecompressMemoryRegionNV *out; unsigned int i; @@ -13078,7 +13072,7 @@ static inline const VkDecompressMemoryRegionNV *convert_VkDecompressMemoryRegion return out; }

-static inline void convert_VkDataGraphPipelineDispatchInfoARM_win32_to_host(const VkDataGraphPipelineDispatchInfoARM32 *in, VkDataGraphPipelineDispatchInfoARM *out) +static void convert_VkDataGraphPipelineDispatchInfoARM_win32_to_host(const VkDataGraphPipelineDispatchInfoARM32 *in, VkDataGraphPipelineDispatchInfoARM *out) { if (!in) return;

@@ -13089,7 +13083,7 @@ static inline void convert_VkDataGraphPipelineDispatchInfoARM_win32_to_host(cons FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDispatchTileInfoQCOM_win32_to_host(const VkDispatchTileInfoQCOM32 *in, VkDispatchTileInfoQCOM *out) +static void convert_VkDispatchTileInfoQCOM_win32_to_host(const VkDispatchTileInfoQCOM32 *in, VkDispatchTileInfoQCOM *out) { if (!in) return;

@@ -13099,7 +13093,7 @@ static inline void convert_VkDispatchTileInfoQCOM_win32_to_host(const VkDispatch FIXME("Unexpected pNext\n"); }

-static inline void convert_StdVideoEncodeH264SliceHeader_win32_to_host(const StdVideoEncodeH264SliceHeader32 *in, StdVideoEncodeH264SliceHeader *out) +static void convert_StdVideoEncodeH264SliceHeader_win32_to_host(const StdVideoEncodeH264SliceHeader32 *in, StdVideoEncodeH264SliceHeader *out) { if (!in) return;

@@ -13115,7 +13109,7 @@ static inline void convert_StdVideoEncodeH264SliceHeader_win32_to_host(const Std out->pWeightTable = UlongToPtr(in->pWeightTable); }

-static inline const StdVideoEncodeH264SliceHeader *convert_StdVideoEncodeH264SliceHeader_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264SliceHeader32 *in, uint32_t count) +static const StdVideoEncodeH264SliceHeader *convert_StdVideoEncodeH264SliceHeader_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264SliceHeader32 *in, uint32_t count) { StdVideoEncodeH264SliceHeader *out; unsigned int i; @@ -13131,7 +13125,7 @@ static inline const StdVideoEncodeH264SliceHeader *convert_StdVideoEncodeH264Sli return out; }

-static inline void convert_VkVideoEncodeH264NaluSliceInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264NaluSliceInfoKHR32 *in, VkVideoEncodeH264NaluSliceInfoKHR *out) +static void convert_VkVideoEncodeH264NaluSliceInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264NaluSliceInfoKHR32 *in, VkVideoEncodeH264NaluSliceInfoKHR *out) { if (!in) return;

@@ -13143,7 +13137,7 @@ static inline void convert_VkVideoEncodeH264NaluSliceInfoKHR_win32_to_host(struc FIXME("Unexpected pNext\n"); }

-static inline const VkVideoEncodeH264NaluSliceInfoKHR *convert_VkVideoEncodeH264NaluSliceInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264NaluSliceInfoKHR32 *in, uint32_t count) +static const VkVideoEncodeH264NaluSliceInfoKHR *convert_VkVideoEncodeH264NaluSliceInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264NaluSliceInfoKHR32 *in, uint32_t count) { VkVideoEncodeH264NaluSliceInfoKHR *out; unsigned int i; @@ -13159,7 +13153,7 @@ static inline const VkVideoEncodeH264NaluSliceInfoKHR *convert_VkVideoEncodeH264 return out; }

-static inline void convert_StdVideoEncodeH264ReferenceListsInfo_win32_to_host(const StdVideoEncodeH264ReferenceListsInfo32 *in, StdVideoEncodeH264ReferenceListsInfo *out) +static void convert_StdVideoEncodeH264ReferenceListsInfo_win32_to_host(const StdVideoEncodeH264ReferenceListsInfo32 *in, StdVideoEncodeH264ReferenceListsInfo *out) { if (!in) return;

@@ -13177,7 +13171,7 @@ static inline void convert_StdVideoEncodeH264ReferenceListsInfo_win32_to_host(co out->pRefPicMarkingOperations = UlongToPtr(in->pRefPicMarkingOperations); }

-static inline const StdVideoEncodeH264ReferenceListsInfo *convert_StdVideoEncodeH264ReferenceListsInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264ReferenceListsInfo32 *in, uint32_t count) +static const StdVideoEncodeH264ReferenceListsInfo *convert_StdVideoEncodeH264ReferenceListsInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264ReferenceListsInfo32 *in, uint32_t count) { StdVideoEncodeH264ReferenceListsInfo *out; unsigned int i; @@ -13193,7 +13187,7 @@ static inline const StdVideoEncodeH264ReferenceListsInfo *convert_StdVideoEncode return out; }

-static inline void convert_StdVideoEncodeH264PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264PictureInfo32 *in, StdVideoEncodeH264PictureInfo *out) +static void convert_StdVideoEncodeH264PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264PictureInfo32 *in, StdVideoEncodeH264PictureInfo *out) { if (!in) return;

@@ -13209,7 +13203,7 @@ static inline void convert_StdVideoEncodeH264PictureInfo_win32_to_host(struct co out->pRefLists = convert_StdVideoEncodeH264ReferenceListsInfo_array_win32_to_host(ctx, (const StdVideoEncodeH264ReferenceListsInfo32 *)UlongToPtr(in->pRefLists), 1); }

-static inline const StdVideoEncodeH264PictureInfo *convert_StdVideoEncodeH264PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264PictureInfo32 *in, uint32_t count) +static const StdVideoEncodeH264PictureInfo *convert_StdVideoEncodeH264PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeH264PictureInfo32 *in, uint32_t count) { StdVideoEncodeH264PictureInfo *out; unsigned int i; @@ -13225,7 +13219,7 @@ static inline const StdVideoEncodeH264PictureInfo *convert_StdVideoEncodeH264Pic return out; }

-static inline void convert_StdVideoEncodeAV1PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, StdVideoEncodeAV1PictureInfo *out) +static void convert_StdVideoEncodeAV1PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, StdVideoEncodeAV1PictureInfo *out) { if (!in) return;

@@ -13258,7 +13252,7 @@ static inline void convert_StdVideoEncodeAV1PictureInfo_win32_to_host(struct con out->pBufferRemovalTimes = UlongToPtr(in->pBufferRemovalTimes); }

-static inline const StdVideoEncodeAV1PictureInfo *convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, uint32_t count) +static const StdVideoEncodeAV1PictureInfo *convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, uint32_t count) { StdVideoEncodeAV1PictureInfo *out; unsigned int i; @@ -13274,7 +13268,7 @@ static inline const StdVideoEncodeAV1PictureInfo *convert_StdVideoEncodeAV1Pictu return out; }

-static inline void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeInfoKHR32 *in, VkVideoEncodeInfoKHR *out) +static void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeInfoKHR32 *in, VkVideoEncodeInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -13372,7 +13366,7 @@ static inline void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_ } }

-static inline void convert_VkPerTileEndInfoQCOM_win32_to_host(const VkPerTileEndInfoQCOM32 *in, VkPerTileEndInfoQCOM *out) +static void convert_VkPerTileEndInfoQCOM_win32_to_host(const VkPerTileEndInfoQCOM32 *in, VkPerTileEndInfoQCOM *out) { if (!in) return;

@@ -13382,7 +13376,7 @@ static inline void convert_VkPerTileEndInfoQCOM_win32_to_host(const VkPerTileEnd FIXME("Unexpected pNext\n"); }

-static inline void convert_VkSubpassEndInfo_win32_to_host(struct conversion_context *ctx, const VkSubpassEndInfo32 *in, VkSubpassEndInfo *out) +static void convert_VkSubpassEndInfo_win32_to_host(struct conversion_context *ctx, const VkSubpassEndInfo32 *in, VkSubpassEndInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -13415,7 +13409,7 @@ static inline void convert_VkSubpassEndInfo_win32_to_host(struct conversion_cont } }

-static inline void convert_VkRenderingEndInfoEXT_win32_to_host(struct conversion_context *ctx, const VkRenderingEndInfoEXT32 *in, VkRenderingEndInfoEXT *out) +static void convert_VkRenderingEndInfoEXT_win32_to_host(struct conversion_context *ctx, const VkRenderingEndInfoEXT32 *in, VkRenderingEndInfoEXT *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -13448,7 +13442,7 @@ static inline void convert_VkRenderingEndInfoEXT_win32_to_host(struct conversion } }

-static inline void convert_VkVideoEndCodingInfoKHR_win32_to_host(const VkVideoEndCodingInfoKHR32 *in, VkVideoEndCodingInfoKHR *out) +static void convert_VkVideoEndCodingInfoKHR_win32_to_host(const VkVideoEndCodingInfoKHR32 *in, VkVideoEndCodingInfoKHR *out) { if (!in) return;

@@ -13460,7 +13454,7 @@ static inline void convert_VkVideoEndCodingInfoKHR_win32_to_host(const VkVideoEn }

#ifdef _WIN64 -static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win64_to_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count) +static const VkCommandBuffer *convert_VkCommandBuffer_array_win64_to_host(struct conversion_context *ctx, const VkCommandBuffer *in, uint32_t count) { VkCommandBuffer *out; unsigned int i; @@ -13477,7 +13471,7 @@ static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win64_to_host } #endif /* _WIN64 */

-static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) +static const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) { VkCommandBuffer *out; unsigned int i; @@ -13493,7 +13487,7 @@ static inline const VkCommandBuffer *convert_VkCommandBuffer_array_win32_to_host return out; }

-static inline void convert_VkGeneratedCommandsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoEXT32 *in, VkGeneratedCommandsInfoEXT *out) +static void convert_VkGeneratedCommandsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoEXT32 *in, VkGeneratedCommandsInfoEXT *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -13547,7 +13541,7 @@ static inline void convert_VkGeneratedCommandsInfoEXT_win32_to_host(struct conve } }

-static inline void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndirectCommandsStreamNV32 *in, VkIndirectCommandsStreamNV *out) +static void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndirectCommandsStreamNV32 *in, VkIndirectCommandsStreamNV *out) { if (!in) return;

@@ -13555,7 +13549,7 @@ static inline void convert_VkIndirectCommandsStreamNV_win32_to_host(const VkIndi out->offset = in->offset; }

-static inline const VkIndirectCommandsStreamNV *convert_VkIndirectCommandsStreamNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsStreamNV32 *in, uint32_t count) +static const VkIndirectCommandsStreamNV *convert_VkIndirectCommandsStreamNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsStreamNV32 *in, uint32_t count) { VkIndirectCommandsStreamNV *out; unsigned int i; @@ -13571,7 +13565,7 @@ static inline const VkIndirectCommandsStreamNV *convert_VkIndirectCommandsStream return out; }

-static inline void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoNV32 *in, VkGeneratedCommandsInfoNV *out) +static void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsInfoNV32 *in, VkGeneratedCommandsInfoNV *out) { if (!in) return;

@@ -13594,7 +13588,7 @@ static inline void convert_VkGeneratedCommandsInfoNV_win32_to_host(struct conver FIXME("Unexpected pNext\n"); }

-static inline void convert_VkOpticalFlowExecuteInfoNV_win32_to_host(const VkOpticalFlowExecuteInfoNV32 *in, VkOpticalFlowExecuteInfoNV *out) +static void convert_VkOpticalFlowExecuteInfoNV_win32_to_host(const VkOpticalFlowExecuteInfoNV32 *in, VkOpticalFlowExecuteInfoNV *out) { if (!in) return;

@@ -13607,7 +13601,7 @@ static inline void convert_VkOpticalFlowExecuteInfoNV_win32_to_host(const VkOpti FIXME("Unexpected pNext\n"); }

-static inline void convert_VkMemoryBarrier_win32_to_host(const VkMemoryBarrier32 *in, VkMemoryBarrier *out) +static void convert_VkMemoryBarrier_win32_to_host(const VkMemoryBarrier32 *in, VkMemoryBarrier *out) { if (!in) return;

@@ -13619,7 +13613,7 @@ static inline void convert_VkMemoryBarrier_win32_to_host(const VkMemoryBarrier32 FIXME("Unexpected pNext\n"); }

-static inline const VkMemoryBarrier *convert_VkMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier32 *in, uint32_t count) +static const VkMemoryBarrier *convert_VkMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier32 *in, uint32_t count) { VkMemoryBarrier *out; unsigned int i; @@ -13635,7 +13629,7 @@ static inline const VkMemoryBarrier *convert_VkMemoryBarrier_array_win32_to_host return out; }

-static inline void convert_VkBufferMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, VkBufferMemoryBarrier *out) +static void convert_VkBufferMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, VkBufferMemoryBarrier *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -13674,7 +13668,7 @@ static inline void convert_VkBufferMemoryBarrier_win32_to_host(struct conversion } }

-static inline const VkBufferMemoryBarrier *convert_VkBufferMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, uint32_t count) +static const VkBufferMemoryBarrier *convert_VkBufferMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier32 *in, uint32_t count) { VkBufferMemoryBarrier *out; unsigned int i; @@ -13690,7 +13684,7 @@ static inline const VkBufferMemoryBarrier *convert_VkBufferMemoryBarrier_array_w return out; }

-static inline void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, VkImageMemoryBarrier *out) +static void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, VkImageMemoryBarrier *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -13744,7 +13738,7 @@ static inline void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_ } }

-static inline const VkImageMemoryBarrier *convert_VkImageMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, uint32_t count) +static const VkImageMemoryBarrier *convert_VkImageMemoryBarrier_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier32 *in, uint32_t count) { VkImageMemoryBarrier *out; unsigned int i; @@ -13760,40 +13754,7 @@ static inline const VkImageMemoryBarrier *convert_VkImageMemoryBarrier_array_win return out; }

-static inline void convert_VkTensorMemoryBarrierARM_win32_to_host(const VkTensorMemoryBarrierARM32 *in, VkTensorMemoryBarrierARM *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->srcStageMask = in->srcStageMask; - out->srcAccessMask = in->srcAccessMask; - out->dstStageMask = in->dstStageMask; - out->dstAccessMask = in->dstAccessMask; - out->srcQueueFamilyIndex = in->srcQueueFamilyIndex; - out->dstQueueFamilyIndex = in->dstQueueFamilyIndex; - out->tensor = in->tensor; - if (in->pNext) - FIXME("Unexpected pNext\n"); -} - -static inline const VkTensorMemoryBarrierARM *convert_VkTensorMemoryBarrierARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorMemoryBarrierARM32 *in, uint32_t count) -{ - VkTensorMemoryBarrierARM *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkTensorMemoryBarrierARM_win32_to_host(&in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkMemoryBarrier2_win32_to_host(const VkMemoryBarrier232 *in, VkMemoryBarrier2 *out) +static void convert_VkMemoryBarrier2_win32_to_host(const VkMemoryBarrier232 *in, VkMemoryBarrier2 *out) { if (!in) return;

@@ -13807,7 +13768,7 @@ static inline void convert_VkMemoryBarrier2_win32_to_host(const VkMemoryBarrier2 FIXME("Unexpected pNext\n"); }

-static inline const VkMemoryBarrier2 *convert_VkMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier232 *in, uint32_t count) +static const VkMemoryBarrier2 *convert_VkMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkMemoryBarrier232 *in, uint32_t count) { VkMemoryBarrier2 *out; unsigned int i; @@ -13823,7 +13784,7 @@ static inline const VkMemoryBarrier2 *convert_VkMemoryBarrier2_array_win32_to_ho return out; }

-static inline void convert_VkBufferMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, VkBufferMemoryBarrier2 *out) +static void convert_VkBufferMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, VkBufferMemoryBarrier2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -13876,7 +13837,7 @@ static inline void convert_VkBufferMemoryBarrier2_win32_to_host(struct conversio } }

-static inline const VkBufferMemoryBarrier2 *convert_VkBufferMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, uint32_t count) +static const VkBufferMemoryBarrier2 *convert_VkBufferMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkBufferMemoryBarrier232 *in, uint32_t count) { VkBufferMemoryBarrier2 *out; unsigned int i; @@ -13892,7 +13853,7 @@ static inline const VkBufferMemoryBarrier2 *convert_VkBufferMemoryBarrier2_array return out; }

-static inline void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, VkImageMemoryBarrier2 *out) +static void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, VkImageMemoryBarrier2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -13960,7 +13921,7 @@ static inline void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion } }

-static inline const VkImageMemoryBarrier2 *convert_VkImageMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, uint32_t count) +static const VkImageMemoryBarrier2 *convert_VkImageMemoryBarrier2_array_win32_to_host(struct conversion_context *ctx, const VkImageMemoryBarrier232 *in, uint32_t count) { VkImageMemoryBarrier2 *out; unsigned int i; @@ -13976,7 +13937,40 @@ static inline const VkImageMemoryBarrier2 *convert_VkImageMemoryBarrier2_array_w return out; }

-static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, VkDependencyInfo *out) +static void convert_VkTensorMemoryBarrierARM_win32_to_host(const VkTensorMemoryBarrierARM32 *in, VkTensorMemoryBarrierARM *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->srcStageMask = in->srcStageMask; + out->srcAccessMask = in->srcAccessMask; + out->dstStageMask = in->dstStageMask; + out->dstAccessMask = in->dstAccessMask; + out->srcQueueFamilyIndex = in->srcQueueFamilyIndex; + out->dstQueueFamilyIndex = in->dstQueueFamilyIndex; + out->tensor = in->tensor; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static const VkTensorMemoryBarrierARM *convert_VkTensorMemoryBarrierARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorMemoryBarrierARM32 *in, uint32_t count) +{ + VkTensorMemoryBarrierARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkTensorMemoryBarrierARM_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, VkDependencyInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -14033,7 +14027,7 @@ static inline void convert_VkDependencyInfo_win32_to_host(struct conversion_cont } }

-static inline void convert_VkPushConstantsInfo_win32_to_host(struct conversion_context *ctx, const VkPushConstantsInfo32 *in, VkPushConstantsInfo *out) +static void convert_VkPushConstantsInfo_win32_to_host(struct conversion_context *ctx, const VkPushConstantsInfo32 *in, VkPushConstantsInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -14074,7 +14068,7 @@ static inline void convert_VkPushConstantsInfo_win32_to_host(struct conversion_c } }

-static inline void convert_VkDescriptorImageInfo_win32_to_host(const VkDescriptorImageInfo32 *in, VkDescriptorImageInfo *out) +static void convert_VkDescriptorImageInfo_win32_to_host(const VkDescriptorImageInfo32 *in, VkDescriptorImageInfo *out) { if (!in) return;

@@ -14083,7 +14077,7 @@ static inline void convert_VkDescriptorImageInfo_win32_to_host(const VkDescripto out->imageLayout = in->imageLayout; }

-static inline const VkDescriptorImageInfo *convert_VkDescriptorImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorImageInfo32 *in, uint32_t count) +static const VkDescriptorImageInfo *convert_VkDescriptorImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorImageInfo32 *in, uint32_t count) { VkDescriptorImageInfo *out; unsigned int i; @@ -14099,7 +14093,7 @@ static inline const VkDescriptorImageInfo *convert_VkDescriptorImageInfo_array_w return out; }

-static inline void convert_VkDescriptorBufferInfo_win32_to_host(const VkDescriptorBufferInfo32 *in, VkDescriptorBufferInfo *out) +static void convert_VkDescriptorBufferInfo_win32_to_host(const VkDescriptorBufferInfo32 *in, VkDescriptorBufferInfo *out) { if (!in) return;

@@ -14108,7 +14102,7 @@ static inline void convert_VkDescriptorBufferInfo_win32_to_host(const VkDescript out->range = in->range; }

-static inline const VkDescriptorBufferInfo *convert_VkDescriptorBufferInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferInfo32 *in, uint32_t count) +static const VkDescriptorBufferInfo *convert_VkDescriptorBufferInfo_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorBufferInfo32 *in, uint32_t count) { VkDescriptorBufferInfo *out; unsigned int i; @@ -14124,7 +14118,7 @@ static inline const VkDescriptorBufferInfo *convert_VkDescriptorBufferInfo_array return out; }

-static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, VkWriteDescriptorSet *out) +static void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, VkWriteDescriptorSet *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -14213,7 +14207,7 @@ static inline void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_ } }

-static inline const VkWriteDescriptorSet *convert_VkWriteDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, uint32_t count) +static const VkWriteDescriptorSet *convert_VkWriteDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkWriteDescriptorSet32 *in, uint32_t count) { VkWriteDescriptorSet *out; unsigned int i; @@ -14229,7 +14223,7 @@ static inline const VkWriteDescriptorSet *convert_VkWriteDescriptorSet_array_win return out; }

-static inline void convert_VkPushDescriptorSetInfo_win32_to_host(struct conversion_context *ctx, const VkPushDescriptorSetInfo32 *in, VkPushDescriptorSetInfo *out) +static void convert_VkPushDescriptorSetInfo_win32_to_host(struct conversion_context *ctx, const VkPushDescriptorSetInfo32 *in, VkPushDescriptorSetInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -14270,7 +14264,7 @@ static inline void convert_VkPushDescriptorSetInfo_win32_to_host(struct conversi } }

-static inline void convert_VkPushDescriptorSetWithTemplateInfo_win32_to_host(struct conversion_context *ctx, const VkPushDescriptorSetWithTemplateInfo32 *in, VkPushDescriptorSetWithTemplateInfo *out) +static void convert_VkPushDescriptorSetWithTemplateInfo_win32_to_host(struct conversion_context *ctx, const VkPushDescriptorSetWithTemplateInfo32 *in, VkPushDescriptorSetWithTemplateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -14310,7 +14304,7 @@ static inline void convert_VkPushDescriptorSetWithTemplateInfo_win32_to_host(str } }

-static inline void convert_VkImageResolve2_win32_to_host(const VkImageResolve232 *in, VkImageResolve2 *out) +static void convert_VkImageResolve2_win32_to_host(const VkImageResolve232 *in, VkImageResolve2 *out) { if (!in) return;

@@ -14325,7 +14319,7 @@ static inline void convert_VkImageResolve2_win32_to_host(const VkImageResolve232 FIXME("Unexpected pNext\n"); }

-static inline const VkImageResolve2 *convert_VkImageResolve2_array_win32_to_host(struct conversion_context *ctx, const VkImageResolve232 *in, uint32_t count) +static const VkImageResolve2 *convert_VkImageResolve2_array_win32_to_host(struct conversion_context *ctx, const VkImageResolve232 *in, uint32_t count) { VkImageResolve2 *out; unsigned int i; @@ -14341,7 +14335,7 @@ static inline const VkImageResolve2 *convert_VkImageResolve2_array_win32_to_host return out; }

-static inline void convert_VkResolveImageInfo2_win32_to_host(struct conversion_context *ctx, const VkResolveImageInfo232 *in, VkResolveImageInfo2 *out) +static void convert_VkResolveImageInfo2_win32_to_host(struct conversion_context *ctx, const VkResolveImageInfo232 *in, VkResolveImageInfo2 *out) { if (!in) return;

@@ -14357,7 +14351,7 @@ static inline void convert_VkResolveImageInfo2_win32_to_host(struct conversion_c FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCoarseSampleOrderCustomNV_win32_to_host(const VkCoarseSampleOrderCustomNV32 *in, VkCoarseSampleOrderCustomNV *out) +static void convert_VkCoarseSampleOrderCustomNV_win32_to_host(const VkCoarseSampleOrderCustomNV32 *in, VkCoarseSampleOrderCustomNV *out) { if (!in) return;

@@ -14367,7 +14361,7 @@ static inline void convert_VkCoarseSampleOrderCustomNV_win32_to_host(const VkCoa out->pSampleLocations = UlongToPtr(in->pSampleLocations); }

-static inline const VkCoarseSampleOrderCustomNV *convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(struct conversion_context *ctx, const VkCoarseSampleOrderCustomNV32 *in, uint32_t count) +static const VkCoarseSampleOrderCustomNV *convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(struct conversion_context *ctx, const VkCoarseSampleOrderCustomNV32 *in, uint32_t count) { VkCoarseSampleOrderCustomNV *out; unsigned int i; @@ -14383,7 +14377,7 @@ static inline const VkCoarseSampleOrderCustomNV *convert_VkCoarseSampleOrderCust return out; }

-static inline void convert_VkDepthBiasInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDepthBiasInfoEXT32 *in, VkDepthBiasInfoEXT *out) +static void convert_VkDepthBiasInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDepthBiasInfoEXT32 *in, VkDepthBiasInfoEXT *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -14419,7 +14413,7 @@ static inline void convert_VkDepthBiasInfoEXT_win32_to_host(struct conversion_co } }

-static inline void convert_VkSetDescriptorBufferOffsetsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkSetDescriptorBufferOffsetsInfoEXT32 *in, VkSetDescriptorBufferOffsetsInfoEXT *out) +static void convert_VkSetDescriptorBufferOffsetsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkSetDescriptorBufferOffsetsInfoEXT32 *in, VkSetDescriptorBufferOffsetsInfoEXT *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -14461,7 +14455,7 @@ static inline void convert_VkSetDescriptorBufferOffsetsInfoEXT_win32_to_host(str } }

-static inline void convert_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPerformanceMarkerInfoINTEL32 *in, VkPerformanceMarkerInfoINTEL *out) +static void convert_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPerformanceMarkerInfoINTEL32 *in, VkPerformanceMarkerInfoINTEL *out) { if (!in) return;

@@ -14472,7 +14466,7 @@ static inline void convert_VkPerformanceMarkerInfoINTEL_win32_to_host(const VkPe FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPerformanceOverrideInfoINTEL_win32_to_host(const VkPerformanceOverrideInfoINTEL32 *in, VkPerformanceOverrideInfoINTEL *out) +static void convert_VkPerformanceOverrideInfoINTEL_win32_to_host(const VkPerformanceOverrideInfoINTEL32 *in, VkPerformanceOverrideInfoINTEL *out) { if (!in) return;

@@ -14485,7 +14479,7 @@ static inline void convert_VkPerformanceOverrideInfoINTEL_win32_to_host(const Vk FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(const VkPerformanceStreamMarkerInfoINTEL32 *in, VkPerformanceStreamMarkerInfoINTEL *out) +static void convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(const VkPerformanceStreamMarkerInfoINTEL32 *in, VkPerformanceStreamMarkerInfoINTEL *out) { if (!in) return;

@@ -14496,7 +14490,7 @@ static inline void convert_VkPerformanceStreamMarkerInfoINTEL_win32_to_host(cons FIXME("Unexpected pNext\n"); }

-static inline void convert_VkRenderingAttachmentLocationInfo_win32_to_host(const VkRenderingAttachmentLocationInfo32 *in, VkRenderingAttachmentLocationInfo *out) +static void convert_VkRenderingAttachmentLocationInfo_win32_to_host(const VkRenderingAttachmentLocationInfo32 *in, VkRenderingAttachmentLocationInfo *out) { if (!in) return;

@@ -14508,7 +14502,7 @@ static inline void convert_VkRenderingAttachmentLocationInfo_win32_to_host(const FIXME("Unexpected pNext\n"); }

-static inline void convert_VkRenderingInputAttachmentIndexInfo_win32_to_host(const VkRenderingInputAttachmentIndexInfo32 *in, VkRenderingInputAttachmentIndexInfo *out) +static void convert_VkRenderingInputAttachmentIndexInfo_win32_to_host(const VkRenderingInputAttachmentIndexInfo32 *in, VkRenderingInputAttachmentIndexInfo *out) { if (!in) return;

@@ -14522,7 +14516,7 @@ static inline void convert_VkRenderingInputAttachmentIndexInfo_win32_to_host(con FIXME("Unexpected pNext\n"); }

-static inline void convert_VkVertexInputBindingDescription2EXT_win32_to_host(const VkVertexInputBindingDescription2EXT32 *in, VkVertexInputBindingDescription2EXT *out) +static void convert_VkVertexInputBindingDescription2EXT_win32_to_host(const VkVertexInputBindingDescription2EXT32 *in, VkVertexInputBindingDescription2EXT *out) { if (!in) return;

@@ -14536,7 +14530,7 @@ static inline void convert_VkVertexInputBindingDescription2EXT_win32_to_host(con FIXME("Unexpected pNext\n"); }

-static inline const VkVertexInputBindingDescription2EXT *convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputBindingDescription2EXT32 *in, uint32_t count) +static const VkVertexInputBindingDescription2EXT *convert_VkVertexInputBindingDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputBindingDescription2EXT32 *in, uint32_t count) { VkVertexInputBindingDescription2EXT *out; unsigned int i; @@ -14552,7 +14546,7 @@ static inline const VkVertexInputBindingDescription2EXT *convert_VkVertexInputBi return out; }

-static inline void convert_VkVertexInputAttributeDescription2EXT_win32_to_host(const VkVertexInputAttributeDescription2EXT32 *in, VkVertexInputAttributeDescription2EXT *out) +static void convert_VkVertexInputAttributeDescription2EXT_win32_to_host(const VkVertexInputAttributeDescription2EXT32 *in, VkVertexInputAttributeDescription2EXT *out) { if (!in) return;

@@ -14566,7 +14560,7 @@ static inline void convert_VkVertexInputAttributeDescription2EXT_win32_to_host(c FIXME("Unexpected pNext\n"); }

-static inline const VkVertexInputAttributeDescription2EXT *convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputAttributeDescription2EXT32 *in, uint32_t count) +static const VkVertexInputAttributeDescription2EXT *convert_VkVertexInputAttributeDescription2EXT_array_win32_to_host(struct conversion_context *ctx, const VkVertexInputAttributeDescription2EXT32 *in, uint32_t count) { VkVertexInputAttributeDescription2EXT *out; unsigned int i; @@ -14582,7 +14576,7 @@ static inline const VkVertexInputAttributeDescription2EXT *convert_VkVertexInput return out; }

-static inline void convert_VkShadingRatePaletteNV_win32_to_host(const VkShadingRatePaletteNV32 *in, VkShadingRatePaletteNV *out) +static void convert_VkShadingRatePaletteNV_win32_to_host(const VkShadingRatePaletteNV32 *in, VkShadingRatePaletteNV *out) { if (!in) return;

@@ -14590,7 +14584,7 @@ static inline void convert_VkShadingRatePaletteNV_win32_to_host(const VkShadingR out->pShadingRatePaletteEntries = UlongToPtr(in->pShadingRatePaletteEntries); }

-static inline const VkShadingRatePaletteNV *convert_VkShadingRatePaletteNV_array_win32_to_host(struct conversion_context *ctx, const VkShadingRatePaletteNV32 *in, uint32_t count) +static const VkShadingRatePaletteNV *convert_VkShadingRatePaletteNV_array_win32_to_host(struct conversion_context *ctx, const VkShadingRatePaletteNV32 *in, uint32_t count) { VkShadingRatePaletteNV *out; unsigned int i; @@ -14606,7 +14600,7 @@ static inline const VkShadingRatePaletteNV *convert_VkShadingRatePaletteNV_array return out; }

-static inline const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, uint32_t count) +static const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_host(struct conversion_context *ctx, const VkDependencyInfo32 *in, uint32_t count) { VkDependencyInfo *out; unsigned int i; @@ -14622,7 +14616,7 @@ static inline const VkDependencyInfo *convert_VkDependencyInfo_array_win32_to_ho return out; }

-static inline void convert_VkCopyImageToImageInfo_win32_to_host(struct conversion_context *ctx, const VkCopyImageToImageInfo32 *in, VkCopyImageToImageInfo *out) +static void convert_VkCopyImageToImageInfo_win32_to_host(struct conversion_context *ctx, const VkCopyImageToImageInfo32 *in, VkCopyImageToImageInfo *out) { if (!in) return;

@@ -14639,7 +14633,7 @@ static inline void convert_VkCopyImageToImageInfo_win32_to_host(struct conversio FIXME("Unexpected pNext\n"); }

-static inline void convert_VkImageToMemoryCopy_win32_to_host(const VkImageToMemoryCopy32 *in, VkImageToMemoryCopy *out) +static void convert_VkImageToMemoryCopy_win32_to_host(const VkImageToMemoryCopy32 *in, VkImageToMemoryCopy *out) { if (!in) return;

@@ -14655,7 +14649,7 @@ static inline void convert_VkImageToMemoryCopy_win32_to_host(const VkImageToMemo FIXME("Unexpected pNext\n"); }

-static inline const VkImageToMemoryCopy *convert_VkImageToMemoryCopy_array_win32_to_host(struct conversion_context *ctx, const VkImageToMemoryCopy32 *in, uint32_t count) +static const VkImageToMemoryCopy *convert_VkImageToMemoryCopy_array_win32_to_host(struct conversion_context *ctx, const VkImageToMemoryCopy32 *in, uint32_t count) { VkImageToMemoryCopy *out; unsigned int i; @@ -14671,7 +14665,7 @@ static inline const VkImageToMemoryCopy *convert_VkImageToMemoryCopy_array_win32 return out; }

-static inline void convert_VkCopyImageToMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkCopyImageToMemoryInfo32 *in, VkCopyImageToMemoryInfo *out) +static void convert_VkCopyImageToMemoryInfo_win32_to_host(struct conversion_context *ctx, const VkCopyImageToMemoryInfo32 *in, VkCopyImageToMemoryInfo *out) { if (!in) return;

@@ -14686,7 +14680,7 @@ static inline void convert_VkCopyImageToMemoryInfo_win32_to_host(struct conversi FIXME("Unexpected pNext\n"); }

-static inline void convert_VkMemoryToImageCopy_win32_to_host(const VkMemoryToImageCopy32 *in, VkMemoryToImageCopy *out) +static void convert_VkMemoryToImageCopy_win32_to_host(const VkMemoryToImageCopy32 *in, VkMemoryToImageCopy *out) { if (!in) return;

@@ -14702,7 +14696,7 @@ static inline void convert_VkMemoryToImageCopy_win32_to_host(const VkMemoryToIma FIXME("Unexpected pNext\n"); }

-static inline const VkMemoryToImageCopy *convert_VkMemoryToImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkMemoryToImageCopy32 *in, uint32_t count) +static const VkMemoryToImageCopy *convert_VkMemoryToImageCopy_array_win32_to_host(struct conversion_context *ctx, const VkMemoryToImageCopy32 *in, uint32_t count) { VkMemoryToImageCopy *out; unsigned int i; @@ -14718,7 +14712,7 @@ static inline const VkMemoryToImageCopy *convert_VkMemoryToImageCopy_array_win32 return out; }

-static inline void convert_VkCopyMemoryToImageInfo_win32_to_host(struct conversion_context *ctx, const VkCopyMemoryToImageInfo32 *in, VkCopyMemoryToImageInfo *out) +static void convert_VkCopyMemoryToImageInfo_win32_to_host(struct conversion_context *ctx, const VkCopyMemoryToImageInfo32 *in, VkCopyMemoryToImageInfo *out) { if (!in) return;

@@ -14733,7 +14727,7 @@ static inline void convert_VkCopyMemoryToImageInfo_win32_to_host(struct conversi FIXME("Unexpected pNext\n"); }

-static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoKHR32 *in, VkAccelerationStructureCreateInfoKHR *out) +static void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoKHR32 *in, VkAccelerationStructureCreateInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -14783,7 +14777,7 @@ static inline void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(st } }

-static inline void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoNV32 *in, VkAccelerationStructureCreateInfoNV *out) +static void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkAccelerationStructureCreateInfoNV32 *in, VkAccelerationStructureCreateInfoNV *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -14817,7 +14811,7 @@ static inline void convert_VkAccelerationStructureCreateInfoNV_win32_to_host(str } }

-static inline void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoProfileInfoKHR32 *in, VkVideoProfileInfoKHR *out) +static void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoProfileInfoKHR32 *in, VkVideoProfileInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -14923,7 +14917,7 @@ static inline void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion } }

-static inline const VkVideoProfileInfoKHR *convert_VkVideoProfileInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoProfileInfoKHR32 *in, uint32_t count) +static const VkVideoProfileInfoKHR *convert_VkVideoProfileInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoProfileInfoKHR32 *in, uint32_t count) { VkVideoProfileInfoKHR *out; unsigned int i; @@ -14939,7 +14933,7 @@ static inline const VkVideoProfileInfoKHR *convert_VkVideoProfileInfoKHR_array_w return out; }

-static inline void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, VkBufferCreateInfo *out) +static void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, VkBufferCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -15044,7 +15038,7 @@ static inline void convert_VkBufferCreateInfo_win32_to_host(struct conversion_co } }

-static inline void convert_VkBufferViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferViewCreateInfo32 *in, VkBufferViewCreateInfo *out) +static void convert_VkBufferViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkBufferViewCreateInfo32 *in, VkBufferViewCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -15081,7 +15075,7 @@ static inline void convert_VkBufferViewCreateInfo_win32_to_host(struct conversio } }

-static inline void convert_VkCommandPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkCommandPoolCreateInfo32 *in, VkCommandPoolCreateInfo *out) +static void convert_VkCommandPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkCommandPoolCreateInfo32 *in, VkCommandPoolCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -15116,104 +15110,23 @@ static inline void convert_VkCommandPoolCreateInfo_win32_to_host(struct conversi } }

-static inline void convert_VkPipelineCreationFeedback_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out) +#ifdef _WIN64 +static void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo *out) { + const VkBaseInStructure *in_header; + VkBaseOutStructure *out_header = (void *)out; + if (!in) return;

+ out->sType = in->sType; + out->pNext = NULL; out->flags = in->flags; - out->duration = in->duration; -} - -static inline VkPipelineCreationFeedback *convert_VkPipelineCreationFeedback_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreationFeedback32 *in, uint32_t count) -{ - VkPipelineCreationFeedback *out; - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - - return out; -} - -static inline void convert_VkPipelineCreationFeedback_array_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out, uint32_t count) -{ - unsigned int i; - - if (!in) return; + out->stage = in->stage; + out->module = in->module; + out->pName = in->pName; + out->pSpecializationInfo = in->pSpecializationInfo;

- for (i = 0; i < count; i++) - { - convert_VkPipelineCreationFeedback_host_to_win32(&in[i], &out[i]); - } -} - -static inline void convert_VkSpecializationMapEntry_win32_to_host(const VkSpecializationMapEntry32 *in, VkSpecializationMapEntry *out) -{ - if (!in) return; - - out->constantID = in->constantID; - out->offset = in->offset; - out->size = in->size; -} - -static inline const VkSpecializationMapEntry *convert_VkSpecializationMapEntry_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationMapEntry32 *in, uint32_t count) -{ - VkSpecializationMapEntry *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkSpecializationMapEntry_win32_to_host(&in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkSpecializationInfo_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, VkSpecializationInfo *out) -{ - if (!in) return; - - out->mapEntryCount = in->mapEntryCount; - out->pMapEntries = convert_VkSpecializationMapEntry_array_win32_to_host(ctx, (const VkSpecializationMapEntry32 *)UlongToPtr(in->pMapEntries), in->mapEntryCount); - out->dataSize = in->dataSize; - out->pData = UlongToPtr(in->pData); -} - -static inline const VkSpecializationInfo *convert_VkSpecializationInfo_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, uint32_t count) -{ - VkSpecializationInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkSpecializationInfo_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - -#ifdef _WIN64 -static inline void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, VkPipelineShaderStageCreateInfo *out) -{ - const VkBaseInStructure *in_header; - VkBaseOutStructure *out_header = (void *)out; - - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->flags = in->flags; - out->stage = in->stage; - out->module = in->module; - out->pName = in->pName; - out->pSpecializationInfo = in->pSpecializationInfo; - - for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) + for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) { switch (in_header->sType) { @@ -15299,7 +15212,91 @@ static inline void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct } #endif /* _WIN64 */

-static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, VkPipelineShaderStageCreateInfo *out) +#ifdef _WIN64 +static void convert_VkComputePipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, VkComputePipelineCreateInfo *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->flags = in->flags; + convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in->stage, &out->stage); + out->layout = in->layout; + out->basePipelineHandle = in->basePipelineHandle; + out->basePipelineIndex = in->basePipelineIndex; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, uint32_t count) +{ + VkComputePipelineCreateInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkComputePipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]); + } + + return out; +} +#endif /* _WIN64 */ + +static void convert_VkSpecializationMapEntry_win32_to_host(const VkSpecializationMapEntry32 *in, VkSpecializationMapEntry *out) +{ + if (!in) return; + + out->constantID = in->constantID; + out->offset = in->offset; + out->size = in->size; +} + +static const VkSpecializationMapEntry *convert_VkSpecializationMapEntry_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationMapEntry32 *in, uint32_t count) +{ + VkSpecializationMapEntry *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkSpecializationMapEntry_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static void convert_VkSpecializationInfo_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, VkSpecializationInfo *out) +{ + if (!in) return; + + out->mapEntryCount = in->mapEntryCount; + out->pMapEntries = convert_VkSpecializationMapEntry_array_win32_to_host(ctx, (const VkSpecializationMapEntry32 *)UlongToPtr(in->pMapEntries), in->mapEntryCount); + out->dataSize = in->dataSize; + out->pData = UlongToPtr(in->pData); +} + +static const VkSpecializationInfo *convert_VkSpecializationInfo_array_win32_to_host(struct conversion_context *ctx, const VkSpecializationInfo32 *in, uint32_t count) +{ + VkSpecializationInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkSpecializationInfo_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, VkPipelineShaderStageCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -15399,22 +15396,17 @@ static inline void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct } }

-#ifdef _WIN64 -static inline void convert_VkComputePipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, VkComputePipelineCreateInfo *out) +static VkPipelineCreationFeedback *convert_VkPipelineCreationFeedback_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreationFeedback32 *in, uint32_t count) { - if (!in) return; + VkPipelineCreationFeedback *out; + if (!in || !count) return NULL;

- out->sType = in->sType; - out->pNext = in->pNext; - out->flags = in->flags; - convert_VkPipelineShaderStageCreateInfo_win64_to_host(ctx, &in->stage, &out->stage); - out->layout = in->layout; - out->basePipelineHandle = in->basePipelineHandle; - out->basePipelineIndex = in->basePipelineIndex; + out = conversion_context_alloc(ctx, count * sizeof(*out)); + + return out; } -#endif /* _WIN64 */

-static inline void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, VkComputePipelineCreateInfo *out) +static void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, VkComputePipelineCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -15526,7 +15518,43 @@ static inline void convert_VkComputePipelineCreateInfo_win32_to_host(struct conv } }

-static inline void convert_VkComputePipelineCreateInfo_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out) +static const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, uint32_t count) +{ + VkComputePipelineCreateInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkComputePipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkPipelineCreationFeedback_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out) +{ + if (!in) return; + + out->flags = in->flags; + out->duration = in->duration; +} + +static void convert_VkPipelineCreationFeedback_array_host_to_win32(const VkPipelineCreationFeedback *in, VkPipelineCreationFeedback32 *out, uint32_t count) +{ + unsigned int i; + + if (!in) return; + + for (i = 0; i < count; i++) + { + convert_VkPipelineCreationFeedback_host_to_win32(&in[i], &out[i]); + } +} + +static void convert_VkComputePipelineCreateInfo_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -15554,41 +15582,7 @@ static inline void convert_VkComputePipelineCreateInfo_host_to_win32(const VkCom } }

-#ifdef _WIN64 -static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo *in, uint32_t count) -{ - VkComputePipelineCreateInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkComputePipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]); - } - - return out; -} -#endif /* _WIN64 */ - -static inline const VkComputePipelineCreateInfo *convert_VkComputePipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkComputePipelineCreateInfo32 *in, uint32_t count) -{ - VkComputePipelineCreateInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkComputePipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkComputePipelineCreateInfo_array_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out, uint32_t count) +static void convert_VkComputePipelineCreateInfo_array_host_to_win32(const VkComputePipelineCreateInfo *in, const VkComputePipelineCreateInfo32 *out, uint32_t count) { unsigned int i;

@@ -15600,7 +15594,7 @@ static inline void convert_VkComputePipelineCreateInfo_array_host_to_win32(const } }

-static inline void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFunctionCreateInfoNVX32 *in, VkCuFunctionCreateInfoNVX *out) +static void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFunctionCreateInfoNVX32 *in, VkCuFunctionCreateInfoNVX *out) { if (!in) return;

@@ -15612,7 +15606,7 @@ static inline void convert_VkCuFunctionCreateInfoNVX_win32_to_host(const VkCuFun FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(struct conversion_context *ctx, const VkCuModuleCreateInfoNVX32 *in, VkCuModuleCreateInfoNVX *out) +static void convert_VkCuModuleCreateInfoNVX_win32_to_host(struct conversion_context *ctx, const VkCuModuleCreateInfoNVX32 *in, VkCuModuleCreateInfoNVX *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -15646,7 +15640,7 @@ static inline void convert_VkCuModuleCreateInfoNVX_win32_to_host(struct conversi } }

-static inline void convert_VkDataGraphPipelineSessionCreateInfoARM_win32_to_host(const VkDataGraphPipelineSessionCreateInfoARM32 *in, VkDataGraphPipelineSessionCreateInfoARM *out) +static void convert_VkDataGraphPipelineSessionCreateInfoARM_win32_to_host(const VkDataGraphPipelineSessionCreateInfoARM32 *in, VkDataGraphPipelineSessionCreateInfoARM *out) { if (!in) return;

@@ -15658,7 +15652,7 @@ static inline void convert_VkDataGraphPipelineSessionCreateInfoARM_win32_to_host FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineConstantARM32 *in, VkDataGraphPipelineConstantARM *out) +static void convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineResourceInfoARM32 *in, VkDataGraphPipelineResourceInfoARM *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -15667,8 +15661,9 @@ static inline void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct c

out->sType = in->sType; out->pNext = NULL; - out->id = in->id; - out->pConstantData = UlongToPtr(in->pConstantData); + out->descriptorSet = in->descriptorSet; + out->binding = in->binding; + out->arrayElement = in->arrayElement;

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) { @@ -15690,19 +15685,6 @@ static inline void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: - { - VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *in_ext = (const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM; - out_ext->pNext = NULL; - out_ext->dimension = in_ext->dimension; - out_ext->zeroCount = in_ext->zeroCount; - out_ext->groupSize = in_ext->groupSize; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -15710,9 +15692,9 @@ static inline void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct c } }

-static inline const VkDataGraphPipelineConstantARM *convert_VkDataGraphPipelineConstantARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineConstantARM32 *in, uint32_t count) +static const VkDataGraphPipelineResourceInfoARM *convert_VkDataGraphPipelineResourceInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineResourceInfoARM32 *in, uint32_t count) { - VkDataGraphPipelineConstantARM *out; + VkDataGraphPipelineResourceInfoARM *out; unsigned int i;

if (!in || !count) return NULL; @@ -15720,13 +15702,13 @@ static inline const VkDataGraphPipelineConstantARM *convert_VkDataGraphPipelineC out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkDataGraphPipelineConstantARM_win32_to_host(ctx, &in[i], &out[i]); + convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(ctx, &in[i], &out[i]); }

return out; }

-static inline void convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineResourceInfoARM32 *in, VkDataGraphPipelineResourceInfoARM *out) +static void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineConstantARM32 *in, VkDataGraphPipelineConstantARM *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -15735,9 +15717,8 @@ static inline void convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(stru

out->sType = in->sType; out->pNext = NULL; - out->descriptorSet = in->descriptorSet; - out->binding = in->binding; - out->arrayElement = in->arrayElement; + out->id = in->id; + out->pConstantData = UlongToPtr(in->pConstantData);

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) { @@ -15759,6 +15740,19 @@ static inline void convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(stru out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: + { + VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *in_ext = (const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM; + out_ext->pNext = NULL; + out_ext->dimension = in_ext->dimension; + out_ext->zeroCount = in_ext->zeroCount; + out_ext->groupSize = in_ext->groupSize; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -15766,9 +15760,9 @@ static inline void convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(stru } }

-static inline const VkDataGraphPipelineResourceInfoARM *convert_VkDataGraphPipelineResourceInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineResourceInfoARM32 *in, uint32_t count) +static const VkDataGraphPipelineConstantARM *convert_VkDataGraphPipelineConstantARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineConstantARM32 *in, uint32_t count) { - VkDataGraphPipelineResourceInfoARM *out; + VkDataGraphPipelineConstantARM *out; unsigned int i;

if (!in || !count) return NULL; @@ -15776,13 +15770,13 @@ static inline const VkDataGraphPipelineResourceInfoARM *convert_VkDataGraphPipel out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkDataGraphPipelineResourceInfoARM_win32_to_host(ctx, &in[i], &out[i]); + convert_VkDataGraphPipelineConstantARM_win32_to_host(ctx, &in[i], &out[i]); }

return out; }

-static inline void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineCreateInfoARM32 *in, VkDataGraphPipelineCreateInfoARM *out) +static void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineCreateInfoARM32 *in, VkDataGraphPipelineCreateInfoARM *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -15870,7 +15864,23 @@ static inline void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct } }

-static inline void convert_VkDataGraphPipelineCreateInfoARM_host_to_win32(const VkDataGraphPipelineCreateInfoARM *in, const VkDataGraphPipelineCreateInfoARM32 *out) +static const VkDataGraphPipelineCreateInfoARM *convert_VkDataGraphPipelineCreateInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineCreateInfoARM32 *in, uint32_t count) +{ + VkDataGraphPipelineCreateInfoARM *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkDataGraphPipelineCreateInfoARM_host_to_win32(const VkDataGraphPipelineCreateInfoARM *in, const VkDataGraphPipelineCreateInfoARM32 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -15907,23 +15917,7 @@ static inline void convert_VkDataGraphPipelineCreateInfoARM_host_to_win32(const } }

-static inline const VkDataGraphPipelineCreateInfoARM *convert_VkDataGraphPipelineCreateInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineCreateInfoARM32 *in, uint32_t count) -{ - VkDataGraphPipelineCreateInfoARM *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkDataGraphPipelineCreateInfoARM_array_host_to_win32(const VkDataGraphPipelineCreateInfoARM *in, const VkDataGraphPipelineCreateInfoARM32 *out, uint32_t count) +static void convert_VkDataGraphPipelineCreateInfoARM_array_host_to_win32(const VkDataGraphPipelineCreateInfoARM *in, const VkDataGraphPipelineCreateInfoARM32 *out, uint32_t count) { unsigned int i;

@@ -15935,7 +15929,7 @@ static inline void convert_VkDataGraphPipelineCreateInfoARM_array_host_to_win32( } }

-static inline void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(const VkDebugReportCallbackCreateInfoEXT32 *in, VkDebugReportCallbackCreateInfoEXT *out) +static void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(const VkDebugReportCallbackCreateInfoEXT32 *in, VkDebugReportCallbackCreateInfoEXT *out) { if (!in) return;

@@ -15948,7 +15942,7 @@ static inline void convert_VkDebugReportCallbackCreateInfoEXT_win32_to_host(cons FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(const VkDebugUtilsMessengerCreateInfoEXT32 *in, VkDebugUtilsMessengerCreateInfoEXT *out) +static void convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(const VkDebugUtilsMessengerCreateInfoEXT32 *in, VkDebugUtilsMessengerCreateInfoEXT *out) { if (!in) return;

@@ -15963,7 +15957,7 @@ static inline void convert_VkDebugUtilsMessengerCreateInfoEXT_win32_to_host(cons FIXME("Unexpected pNext\n"); }

-static inline void convert_VkMutableDescriptorTypeListEXT_win32_to_host(const VkMutableDescriptorTypeListEXT32 *in, VkMutableDescriptorTypeListEXT *out) +static void convert_VkMutableDescriptorTypeListEXT_win32_to_host(const VkMutableDescriptorTypeListEXT32 *in, VkMutableDescriptorTypeListEXT *out) { if (!in) return;

@@ -15971,7 +15965,7 @@ static inline void convert_VkMutableDescriptorTypeListEXT_win32_to_host(const Vk out->pDescriptorTypes = UlongToPtr(in->pDescriptorTypes); }

-static inline const VkMutableDescriptorTypeListEXT *convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(struct conversion_context *ctx, const VkMutableDescriptorTypeListEXT32 *in, uint32_t count) +static const VkMutableDescriptorTypeListEXT *convert_VkMutableDescriptorTypeListEXT_array_win32_to_host(struct conversion_context *ctx, const VkMutableDescriptorTypeListEXT32 *in, uint32_t count) { VkMutableDescriptorTypeListEXT *out; unsigned int i; @@ -15987,7 +15981,7 @@ static inline const VkMutableDescriptorTypeListEXT *convert_VkMutableDescriptorT return out; }

-static inline void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorPoolCreateInfo32 *in, VkDescriptorPoolCreateInfo *out) +static void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorPoolCreateInfo32 *in, VkDescriptorPoolCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -16047,7 +16041,7 @@ static inline void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conve } }

-static inline void convert_VkDescriptorSetLayoutBinding_win32_to_host(const VkDescriptorSetLayoutBinding32 *in, VkDescriptorSetLayoutBinding *out) +static void convert_VkDescriptorSetLayoutBinding_win32_to_host(const VkDescriptorSetLayoutBinding32 *in, VkDescriptorSetLayoutBinding *out) { if (!in) return;

@@ -16058,7 +16052,7 @@ static inline void convert_VkDescriptorSetLayoutBinding_win32_to_host(const VkDe out->pImmutableSamplers = UlongToPtr(in->pImmutableSamplers); }

-static inline const VkDescriptorSetLayoutBinding *convert_VkDescriptorSetLayoutBinding_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutBinding32 *in, uint32_t count) +static const VkDescriptorSetLayoutBinding *convert_VkDescriptorSetLayoutBinding_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutBinding32 *in, uint32_t count) { VkDescriptorSetLayoutBinding *out; unsigned int i; @@ -16074,7 +16068,7 @@ static inline const VkDescriptorSetLayoutBinding *convert_VkDescriptorSetLayoutB return out; }

-static inline void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutCreateInfo32 *in, VkDescriptorSetLayoutCreateInfo *out) +static void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutCreateInfo32 *in, VkDescriptorSetLayoutCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -16122,7 +16116,7 @@ static inline void convert_VkDescriptorSetLayoutCreateInfo_win32_to_host(struct } }

-static inline void convert_VkDescriptorUpdateTemplateEntry_win32_to_host(const VkDescriptorUpdateTemplateEntry32 *in, VkDescriptorUpdateTemplateEntry *out) +static void convert_VkDescriptorUpdateTemplateEntry_win32_to_host(const VkDescriptorUpdateTemplateEntry32 *in, VkDescriptorUpdateTemplateEntry *out) { if (!in) return;

@@ -16134,7 +16128,7 @@ static inline void convert_VkDescriptorUpdateTemplateEntry_win32_to_host(const V out->stride = in->stride; }

-static inline const VkDescriptorUpdateTemplateEntry *convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateEntry32 *in, uint32_t count) +static const VkDescriptorUpdateTemplateEntry *convert_VkDescriptorUpdateTemplateEntry_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateEntry32 *in, uint32_t count) { VkDescriptorUpdateTemplateEntry *out; unsigned int i; @@ -16150,7 +16144,7 @@ static inline const VkDescriptorUpdateTemplateEntry *convert_VkDescriptorUpdateT return out; }

-static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateCreateInfo32 *in, VkDescriptorUpdateTemplateCreateInfo *out) +static void convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDescriptorUpdateTemplateCreateInfo32 *in, VkDescriptorUpdateTemplateCreateInfo *out) { if (!in) return;

@@ -16169,7 +16163,7 @@ static inline void convert_VkDescriptorUpdateTemplateCreateInfo_win32_to_host(st }

#ifdef _WIN64 -static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win64_to_host(struct conversion_context *ctx, const VkPhysicalDevice *in, uint32_t count) +static const VkPhysicalDevice *convert_VkPhysicalDevice_array_win64_to_host(struct conversion_context *ctx, const VkPhysicalDevice *in, uint32_t count) { VkPhysicalDevice *out; unsigned int i; @@ -16186,103 +16180,8 @@ static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win64_to_ho } #endif /* _WIN64 */

-static inline const VkPhysicalDevice *convert_VkPhysicalDevice_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) -{ - VkPhysicalDevice *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - out[i] = vulkan_physical_device_from_handle(UlongToPtr(in[i]))->host.physical_device; - } - - return out; -} - -static inline void convert_VkDeviceQueueCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, VkDeviceQueueCreateInfo *out) -{ - const VkBaseInStructure32 *in_header; - VkBaseOutStructure *out_header = (void *)out; - - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->flags = in->flags; - out->queueFamilyIndex = in->queueFamilyIndex; - out->queueCount = in->queueCount; - out->pQueuePriorities = UlongToPtr(in->pQueuePriorities); - - for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) - { - switch (in_header->sType) - { - case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: - { - VkDeviceQueueGlobalPriorityCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDeviceQueueGlobalPriorityCreateInfo32 *in_ext = (const VkDeviceQueueGlobalPriorityCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO; - out_ext->pNext = NULL; - out_ext->globalPriority = in_ext->globalPriority; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: - { - VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDeviceQueueShaderCoreControlCreateInfoARM32 *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; - out_ext->pNext = NULL; - out_ext->shaderCoreCount = in_ext->shaderCoreCount; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - default: - FIXME("Unhandled sType %u.\n", in_header->sType); - break; - } - } -} - -static inline const VkDeviceQueueCreateInfo *convert_VkDeviceQueueCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, uint32_t count) -{ - VkDeviceQueueCreateInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkDeviceQueueCreateInfo_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - -static inline const char * const*convert_char_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) -{ - char **out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - out[i] = UlongToPtr(in[i]); - } - - return (void *)out; -} - #ifdef _WIN64 -static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo *in, VkDeviceCreateInfo *out) +static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo *in, VkDeviceCreateInfo *out) { const VkBaseInStructure *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -19091,7 +18990,102 @@ static inline void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_co } #endif /* _WIN64 */

-static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo32 *in, VkDeviceCreateInfo *out) +static void convert_VkDeviceQueueCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, VkDeviceQueueCreateInfo *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->queueFamilyIndex = in->queueFamilyIndex; + out->queueCount = in->queueCount; + out->pQueuePriorities = UlongToPtr(in->pQueuePriorities); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: + { + VkDeviceQueueGlobalPriorityCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDeviceQueueGlobalPriorityCreateInfo32 *in_ext = (const VkDeviceQueueGlobalPriorityCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->globalPriority = in_ext->globalPriority; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + { + VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDeviceQueueShaderCoreControlCreateInfoARM32 *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; + out_ext->pNext = NULL; + out_ext->shaderCoreCount = in_ext->shaderCoreCount; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} + +static const VkDeviceQueueCreateInfo *convert_VkDeviceQueueCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkDeviceQueueCreateInfo32 *in, uint32_t count) +{ + VkDeviceQueueCreateInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkDeviceQueueCreateInfo_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static const char * const*convert_char_pointer_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) +{ + char **out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + out[i] = UlongToPtr(in[i]); + } + + return (void *)out; +} + +static const VkPhysicalDevice *convert_VkPhysicalDevice_array_win32_to_host(struct conversion_context *ctx, const PTR32 *in, uint32_t count) +{ + VkPhysicalDevice *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + out[i] = vulkan_physical_device_from_handle(UlongToPtr(in[i]))->host.physical_device; + } + + return out; +} + +static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceCreateInfo32 *in, VkDeviceCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -21899,7 +21893,7 @@ static inline void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_co } }

-static inline void convert_VkEventCreateInfo_win32_to_host(const VkEventCreateInfo32 *in, VkEventCreateInfo *out) +static void convert_VkEventCreateInfo_win32_to_host(const VkEventCreateInfo32 *in, VkEventCreateInfo *out) { if (!in) return;

@@ -21910,7 +21904,7 @@ static inline void convert_VkEventCreateInfo_win32_to_host(const VkEventCreateIn FIXME("Unexpected pNext\n"); }

-static inline void convert_VkFenceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFenceCreateInfo32 *in, VkFenceCreateInfo *out) +static void convert_VkFenceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFenceCreateInfo32 *in, VkFenceCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -21943,7 +21937,7 @@ static inline void convert_VkFenceCreateInfo_win32_to_host(struct conversion_con } }

-static inline void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const VkFramebufferAttachmentImageInfo32 *in, VkFramebufferAttachmentImageInfo *out) +static void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const VkFramebufferAttachmentImageInfo32 *in, VkFramebufferAttachmentImageInfo *out) { if (!in) return;

@@ -21960,7 +21954,7 @@ static inline void convert_VkFramebufferAttachmentImageInfo_win32_to_host(const FIXME("Unexpected pNext\n"); }

-static inline const VkFramebufferAttachmentImageInfo *convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferAttachmentImageInfo32 *in, uint32_t count) +static const VkFramebufferAttachmentImageInfo *convert_VkFramebufferAttachmentImageInfo_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferAttachmentImageInfo32 *in, uint32_t count) { VkFramebufferAttachmentImageInfo *out; unsigned int i; @@ -21976,7 +21970,7 @@ static inline const VkFramebufferAttachmentImageInfo *convert_VkFramebufferAttac return out; }

-static inline void convert_VkFramebufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFramebufferCreateInfo32 *in, VkFramebufferCreateInfo *out) +static void convert_VkFramebufferCreateInfo_win32_to_host(struct conversion_context *ctx, const VkFramebufferCreateInfo32 *in, VkFramebufferCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -22017,7 +22011,7 @@ static inline void convert_VkFramebufferCreateInfo_win32_to_host(struct conversi }

#ifdef _WIN64 -static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, uint32_t count) +static const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo *in, uint32_t count) { VkPipelineShaderStageCreateInfo *out; unsigned int i; @@ -22034,9 +22028,24 @@ static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderSta } #endif /* _WIN64 */

-static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, uint32_t count) +#ifdef _WIN64 +static void convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, VkGraphicsShaderGroupCreateInfoNV *out) { - VkPipelineShaderStageCreateInfo *out; + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->stageCount = in->stageCount; + out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount); + out->pVertexInputState = in->pVertexInputState; + out->pTessellationState = in->pTessellationState; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, uint32_t count) +{ + VkGraphicsShaderGroupCreateInfoNV *out; unsigned int i;

if (!in || !count) return NULL; @@ -22044,15 +22053,17 @@ static inline const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderSta out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in[i], &out[i]); + convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]); }

return out; } +#endif /* _WIN64 */

-static inline void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, VkPipelineVertexInputStateCreateInfo *out) +#ifdef _WIN64 +static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, VkGraphicsPipelineCreateInfo *out) { - const VkBaseInStructure32 *in_header; + const VkBaseInStructure *in_header; VkBaseOutStructure *out_header = (void *)out;

if (!in) return; @@ -22060,426 +22071,236 @@ static inline void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(st out->sType = in->sType; out->pNext = NULL; out->flags = in->flags; - out->vertexBindingDescriptionCount = in->vertexBindingDescriptionCount; - out->pVertexBindingDescriptions = UlongToPtr(in->pVertexBindingDescriptions); - out->vertexAttributeDescriptionCount = in->vertexAttributeDescriptionCount; - out->pVertexAttributeDescriptions = UlongToPtr(in->pVertexAttributeDescriptions); + out->stageCount = in->stageCount; + out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount); + out->pVertexInputState = in->pVertexInputState; + out->pInputAssemblyState = in->pInputAssemblyState; + out->pTessellationState = in->pTessellationState; + out->pViewportState = in->pViewportState; + out->pRasterizationState = in->pRasterizationState; + out->pMultisampleState = in->pMultisampleState; + out->pDepthStencilState = in->pDepthStencilState; + out->pColorBlendState = in->pColorBlendState; + out->pDynamicState = in->pDynamicState; + out->layout = in->layout; + out->renderPass = in->renderPass; + out->subpass = in->subpass; + out->basePipelineHandle = in->basePipelineHandle; + out->basePipelineIndex = in->basePipelineIndex;

- for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: { - VkPipelineVertexInputDivisorStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineVertexInputDivisorStateCreateInfo32 *in_ext = (const VkPipelineVertexInputDivisorStateCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO; + VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCreateFlags2CreateInfo *in_ext = (const VkPipelineCreateFlags2CreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; out_ext->pNext = NULL; - out_ext->vertexBindingDivisorCount = in_ext->vertexBindingDivisorCount; - out_ext->pVertexBindingDivisors = UlongToPtr(in_ext->pVertexBindingDivisors); + out_ext->flags = in_ext->flags; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - default: - FIXME("Unhandled sType %u.\n", in_header->sType); - break; - } - } -} - -static inline const VkPipelineVertexInputStateCreateInfo *convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, uint32_t count) -{ - VkPipelineVertexInputStateCreateInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkPipelineTessellationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, VkPipelineTessellationStateCreateInfo *out) -{ - const VkBaseInStructure32 *in_header; - VkBaseOutStructure *out_header = (void *)out; - - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->flags = in->flags; - out->patchControlPoints = in->patchControlPoints; - - for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) - { - switch (in_header->sType) - { - case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: { - VkPipelineTessellationDomainOriginStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineTessellationDomainOriginStateCreateInfo32 *in_ext = (const VkPipelineTessellationDomainOriginStateCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO; + VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineBinaryInfoKHR *in_ext = (const VkPipelineBinaryInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; out_ext->pNext = NULL; - out_ext->domainOrigin = in_ext->domainOrigin; + out_ext->binaryCount = in_ext->binaryCount; + out_ext->pPipelineBinaries = in_ext->pPipelineBinaries; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - default: - FIXME("Unhandled sType %u.\n", in_header->sType); - break; - } - } -} - -static inline const VkPipelineTessellationStateCreateInfo *convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, uint32_t count) -{ - VkPipelineTessellationStateCreateInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkPipelineTessellationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - -#ifdef _WIN64 -static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, VkGraphicsShaderGroupCreateInfoNV *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = in->pNext; - out->stageCount = in->stageCount; - out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount); - out->pVertexInputState = in->pVertexInputState; - out->pTessellationState = in->pTessellationState; -} -#endif /* _WIN64 */ - -static inline void convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, VkGraphicsShaderGroupCreateInfoNV *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->stageCount = in->stageCount; - out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount); - out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1); - out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1); - if (in->pNext) - FIXME("Unexpected pNext\n"); -} - -#ifdef _WIN64 -static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV *in, uint32_t count) -{ - VkGraphicsShaderGroupCreateInfoNV *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkGraphicsShaderGroupCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]); - } - - return out; -} -#endif /* _WIN64 */ - -static inline const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, uint32_t count) -{ - VkGraphicsShaderGroupCreateInfoNV *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(const VkPipelineInputAssemblyStateCreateInfo32 *in, VkPipelineInputAssemblyStateCreateInfo *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->flags = in->flags; - out->topology = in->topology; - out->primitiveRestartEnable = in->primitiveRestartEnable; - if (in->pNext) - FIXME("Unexpected pNext\n"); -} - -static inline const VkPipelineInputAssemblyStateCreateInfo *convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineInputAssemblyStateCreateInfo32 *in, uint32_t count) -{ - VkPipelineInputAssemblyStateCreateInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(&in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, VkPipelineViewportStateCreateInfo *out) -{ - const VkBaseInStructure32 *in_header; - VkBaseOutStructure *out_header = (void *)out; - - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->flags = in->flags; - out->viewportCount = in->viewportCount; - out->pViewports = UlongToPtr(in->pViewports); - out->scissorCount = in->scissorCount; - out->pScissors = UlongToPtr(in->pScissors); - - for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) - { - switch (in_header->sType) - { - case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: { - VkPipelineViewportWScalingStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineViewportWScalingStateCreateInfoNV32 *in_ext = (const VkPipelineViewportWScalingStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV; + VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkGraphicsPipelineShaderGroupsCreateInfoNV *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV; out_ext->pNext = NULL; - out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable; - out_ext->viewportCount = in_ext->viewportCount; - out_ext->pViewportWScalings = UlongToPtr(in_ext->pViewportWScalings); + out_ext->groupCount = in_ext->groupCount; + out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(ctx, in_ext->pGroups, in_ext->groupCount); + out_ext->pipelineCount = in_ext->pipelineCount; + out_ext->pPipelines = in_ext->pPipelines; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: { - VkPipelineViewportSwizzleStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineViewportSwizzleStateCreateInfoNV32 *in_ext = (const VkPipelineViewportSwizzleStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; + VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; out_ext->pNext = NULL; out_ext->flags = in_ext->flags; - out_ext->viewportCount = in_ext->viewportCount; - out_ext->pViewportSwizzles = UlongToPtr(in_ext->pViewportSwizzles); + out_ext->discardRectangleMode = in_ext->discardRectangleMode; + out_ext->discardRectangleCount = in_ext->discardRectangleCount; + out_ext->pDiscardRectangles = in_ext->pDiscardRectangles; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: { - VkPipelineViewportExclusiveScissorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *in_ext = (const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV; + VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV; out_ext->pNext = NULL; - out_ext->exclusiveScissorCount = in_ext->exclusiveScissorCount; - out_ext->pExclusiveScissors = UlongToPtr(in_ext->pExclusiveScissors); + out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: { - VkPipelineViewportShadingRateImageStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *in_ext = (const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV; + VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; out_ext->pNext = NULL; - out_ext->shadingRateImageEnable = in_ext->shadingRateImageEnable; - out_ext->viewportCount = in_ext->viewportCount; - out_ext->pShadingRatePalettes = convert_VkShadingRatePaletteNV_array_win32_to_host(ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(in_ext->pShadingRatePalettes), in_ext->viewportCount); + out_ext->pPipelineCreationFeedback = in_ext->pPipelineCreationFeedback; + out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount; + out_ext->pPipelineStageCreationFeedbacks = in_ext->pPipelineStageCreationFeedbacks; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: { - VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *in_ext = (const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV; + VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; out_ext->pNext = NULL; - out_ext->sampleOrderType = in_ext->sampleOrderType; - out_ext->customSampleOrderCount = in_ext->customSampleOrderCount; - out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(in_ext->pCustomSampleOrders), in_ext->customSampleOrderCount); + out_ext->compilerControlFlags = in_ext->compilerControlFlags; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: { - VkPipelineViewportDepthClipControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineViewportDepthClipControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClipControlCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; + VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR; out_ext->pNext = NULL; - out_ext->negativeOneToOne = in_ext->negativeOneToOne; + out_ext->libraryCount = in_ext->libraryCount; + out_ext->pLibraries = in_ext->pLibraries; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: { - VkPipelineViewportDepthClampControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineViewportDepthClampControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClampControlCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; + VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineFragmentShadingRateStateCreateInfoKHR *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR; out_ext->pNext = NULL; - out_ext->depthClampMode = in_ext->depthClampMode; - out_ext->pDepthClampRange = UlongToPtr(in_ext->pDepthClampRange); + out_ext->fragmentSize = in_ext->fragmentSize; + memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR)); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - default: - FIXME("Unhandled sType %u.\n", in_header->sType); + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: + { + VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV; + out_ext->pNext = NULL; + out_ext->shadingRateType = in_ext->shadingRateType; + out_ext->shadingRate = in_ext->shadingRate; + memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR)); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; break; } - } -} - -static inline const VkPipelineViewportStateCreateInfo *convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, uint32_t count) -{ - VkPipelineViewportStateCreateInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkPipelineViewportStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, VkPipelineRasterizationStateCreateInfo *out) -{ - const VkBaseInStructure32 *in_header; - VkBaseOutStructure *out_header = (void *)out; - - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->flags = in->flags; - out->depthClampEnable = in->depthClampEnable; - out->rasterizerDiscardEnable = in->rasterizerDiscardEnable; - out->polygonMode = in->polygonMode; - out->cullMode = in->cullMode; - out->frontFace = in->frontFace; - out->depthBiasEnable = in->depthBiasEnable; - out->depthBiasConstantFactor = in->depthBiasConstantFactor; - out->depthBiasClamp = in->depthBiasClamp; - out->depthBiasSlopeFactor = in->depthBiasSlopeFactor; - out->lineWidth = in->lineWidth; - - for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) - { - switch (in_header->sType) - { - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: { - VkPipelineRasterizationStateRasterizationOrderAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRasterizationStateRasterizationOrderAMD32 *in_ext = (const VkPipelineRasterizationStateRasterizationOrderAMD32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; + VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRenderingCreateInfo *in_ext = (const VkPipelineRenderingCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO; out_ext->pNext = NULL; - out_ext->rasterizationOrder = in_ext->rasterizationOrder; + out_ext->viewMask = in_ext->viewMask; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats; + out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat; + out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: { - VkPipelineRasterizationConservativeStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT; + VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->conservativeRasterizationMode = in_ext->conservativeRasterizationMode; - out_ext->extraPrimitiveOverestimationSize = in_ext->extraPrimitiveOverestimationSize; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples; + out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: { - VkPipelineRasterizationStateStreamCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRasterizationStateStreamCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationStateStreamCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; + VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; out_ext->pNext = NULL; out_ext->flags = in_ext->flags; - out_ext->rasterizationStream = in_ext->rasterizationStream; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: { - VkPipelineRasterizationDepthClipStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT; + VkPipelineRobustnessCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRobustnessCreateInfo *in_ext = (const VkPipelineRobustnessCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->depthClipEnable = in_ext->depthClipEnable; + out_ext->storageBuffers = in_ext->storageBuffers; + out_ext->uniformBuffers = in_ext->uniformBuffers; + out_ext->vertexInputs = in_ext->vertexInputs; + out_ext->images = in_ext->images; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: { - VkPipelineRasterizationLineStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRasterizationLineStateCreateInfo32 *in_ext = (const VkPipelineRasterizationLineStateCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO; + VkRenderingAttachmentLocationInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderingAttachmentLocationInfo *in_ext = (const VkRenderingAttachmentLocationInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO; out_ext->pNext = NULL; - out_ext->lineRasterizationMode = in_ext->lineRasterizationMode; - out_ext->stippledLineEnable = in_ext->stippledLineEnable; - out_ext->lineStippleFactor = in_ext->lineStippleFactor; - out_ext->lineStipplePattern = in_ext->lineStipplePattern; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentLocations = in_ext->pColorAttachmentLocations; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: { - VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT; + VkRenderingInputAttachmentIndexInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderingInputAttachmentIndexInfo *in_ext = (const VkRenderingInputAttachmentIndexInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO; out_ext->pNext = NULL; - out_ext->provokingVertexMode = in_ext->provokingVertexMode; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentInputIndices = in_ext->pColorAttachmentInputIndices; + out_ext->pDepthInputAttachmentIndex = in_ext->pDepthInputAttachmentIndex; + out_ext->pStencilInputAttachmentIndex = in_ext->pStencilInputAttachmentIndex; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: { - VkDepthBiasRepresentationInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDepthBiasRepresentationInfoEXT32 *in_ext = (const VkDepthBiasRepresentationInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT; + VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE; out_ext->pNext = NULL; - out_ext->depthBiasRepresentation = in_ext->depthBiasRepresentation; - out_ext->depthBiasExact = in_ext->depthBiasExact; + out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22490,10 +22311,12 @@ static inline void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host( } } } +#endif /* _WIN64 */

-static inline const VkPipelineRasterizationStateCreateInfo *convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, uint32_t count) +#ifdef _WIN64 +static const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, uint32_t count) { - VkPipelineRasterizationStateCreateInfo *out; + VkGraphicsPipelineCreateInfo *out; unsigned int i;

if (!in || !count) return NULL; @@ -22501,81 +22324,56 @@ static inline const VkPipelineRasterizationStateCreateInfo *convert_VkPipelineRa out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]); + convert_VkGraphicsPipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]); }

return out; } +#endif /* _WIN64 */

-static inline void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, VkPipelineMultisampleStateCreateInfo *out) +static const VkPipelineShaderStageCreateInfo *convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineShaderStageCreateInfo32 *in, uint32_t count) { - const VkBaseInStructure32 *in_header; - VkBaseOutStructure *out_header = (void *)out; - - if (!in) return; + VkPipelineShaderStageCreateInfo *out; + unsigned int i;

- out->sType = in->sType; - out->pNext = NULL; - out->flags = in->flags; - out->rasterizationSamples = in->rasterizationSamples; - out->sampleShadingEnable = in->sampleShadingEnable; - out->minSampleShading = in->minSampleShading; - out->pSampleMask = UlongToPtr(in->pSampleMask); - out->alphaToCoverageEnable = in->alphaToCoverageEnable; - out->alphaToOneEnable = in->alphaToOneEnable; + if (!in || !count) return NULL;

- for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) { - switch (in_header->sType) - { - case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: - { - VkPipelineCoverageToColorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCoverageToColorStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageToColorStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV; - out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->coverageToColorEnable = in_ext->coverageToColorEnable; - out_ext->coverageToColorLocation = in_ext->coverageToColorLocation; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: - { - VkPipelineSampleLocationsStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineSampleLocationsStateCreateInfoEXT32 *in_ext = (const VkPipelineSampleLocationsStateCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT; - out_ext->pNext = NULL; - out_ext->sampleLocationsEnable = in_ext->sampleLocationsEnable; - convert_VkSampleLocationsInfoEXT_win32_to_host(&in_ext->sampleLocationsInfo, &out_ext->sampleLocationsInfo); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: + convert_VkPipelineShaderStageCreateInfo_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, VkPipelineVertexInputStateCreateInfo *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->vertexBindingDescriptionCount = in->vertexBindingDescriptionCount; + out->pVertexBindingDescriptions = UlongToPtr(in->pVertexBindingDescriptions); + out->vertexAttributeDescriptionCount = in->vertexAttributeDescriptionCount; + out->pVertexAttributeDescriptions = UlongToPtr(in->pVertexAttributeDescriptions); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) { - VkPipelineCoverageModulationStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCoverageModulationStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageModulationStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV; - out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->coverageModulationMode = in_ext->coverageModulationMode; - out_ext->coverageModulationTableEnable = in_ext->coverageModulationTableEnable; - out_ext->coverageModulationTableCount = in_ext->coverageModulationTableCount; - out_ext->pCoverageModulationTable = UlongToPtr(in_ext->pCoverageModulationTable); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: { - VkPipelineCoverageReductionStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCoverageReductionStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageReductionStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV; + VkPipelineVertexInputDivisorStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineVertexInputDivisorStateCreateInfo32 *in_ext = (const VkPipelineVertexInputDivisorStateCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->coverageReductionMode = in_ext->coverageReductionMode; + out_ext->vertexBindingDivisorCount = in_ext->vertexBindingDivisorCount; + out_ext->pVertexBindingDivisors = UlongToPtr(in_ext->pVertexBindingDivisors); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22587,9 +22385,9 @@ static inline void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(st } }

-static inline const VkPipelineMultisampleStateCreateInfo *convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, uint32_t count) +static const VkPipelineVertexInputStateCreateInfo *convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineVertexInputStateCreateInfo32 *in, uint32_t count) { - VkPipelineMultisampleStateCreateInfo *out; + VkPipelineVertexInputStateCreateInfo *out; unsigned int i;

if (!in || !count) return NULL; @@ -22597,35 +22395,28 @@ static inline const VkPipelineMultisampleStateCreateInfo *convert_VkPipelineMult out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]); + convert_VkPipelineVertexInputStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]); }

return out; }

-static inline void convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(const VkPipelineDepthStencilStateCreateInfo32 *in, VkPipelineDepthStencilStateCreateInfo *out) +static void convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(const VkPipelineInputAssemblyStateCreateInfo32 *in, VkPipelineInputAssemblyStateCreateInfo *out) { if (!in) return;

out->sType = in->sType; out->pNext = NULL; out->flags = in->flags; - out->depthTestEnable = in->depthTestEnable; - out->depthWriteEnable = in->depthWriteEnable; - out->depthCompareOp = in->depthCompareOp; - out->depthBoundsTestEnable = in->depthBoundsTestEnable; - out->stencilTestEnable = in->stencilTestEnable; - out->front = in->front; - out->back = in->back; - out->minDepthBounds = in->minDepthBounds; - out->maxDepthBounds = in->maxDepthBounds; + out->topology = in->topology; + out->primitiveRestartEnable = in->primitiveRestartEnable; if (in->pNext) FIXME("Unexpected pNext\n"); }

-static inline const VkPipelineDepthStencilStateCreateInfo *convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDepthStencilStateCreateInfo32 *in, uint32_t count) +static const VkPipelineInputAssemblyStateCreateInfo *convert_VkPipelineInputAssemblyStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineInputAssemblyStateCreateInfo32 *in, uint32_t count) { - VkPipelineDepthStencilStateCreateInfo *out; + VkPipelineInputAssemblyStateCreateInfo *out; unsigned int i;

if (!in || !count) return NULL; @@ -22633,13 +22424,13 @@ static inline const VkPipelineDepthStencilStateCreateInfo *convert_VkPipelineDep out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(&in[i], &out[i]); + convert_VkPipelineInputAssemblyStateCreateInfo_win32_to_host(&in[i], &out[i]); }

return out; }

-static inline void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, VkPipelineColorBlendStateCreateInfo *out) +static void convert_VkPipelineTessellationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, VkPipelineTessellationStateCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -22649,37 +22440,19 @@ static inline void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(str out->sType = in->sType; out->pNext = NULL; out->flags = in->flags; - out->logicOpEnable = in->logicOpEnable; - out->logicOp = in->logicOp; - out->attachmentCount = in->attachmentCount; - out->pAttachments = UlongToPtr(in->pAttachments); - memcpy(out->blendConstants, in->blendConstants, 4 * sizeof(float)); + out->patchControlPoints = in->patchControlPoints;

for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: - { - VkPipelineColorBlendAdvancedStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *in_ext = (const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT; - out_ext->pNext = NULL; - out_ext->srcPremultiplied = in_ext->srcPremultiplied; - out_ext->dstPremultiplied = in_ext->dstPremultiplied; - out_ext->blendOverlap = in_ext->blendOverlap; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: { - VkPipelineColorWriteCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineColorWriteCreateInfoEXT32 *in_ext = (const VkPipelineColorWriteCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT; + VkPipelineTessellationDomainOriginStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineTessellationDomainOriginStateCreateInfo32 *in_ext = (const VkPipelineTessellationDomainOriginStateCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO; out_ext->pNext = NULL; - out_ext->attachmentCount = in_ext->attachmentCount; - out_ext->pColorWriteEnables = UlongToPtr(in_ext->pColorWriteEnables); + out_ext->domainOrigin = in_ext->domainOrigin; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22691,9 +22464,9 @@ static inline void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(str } }

-static inline const VkPipelineColorBlendStateCreateInfo *convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, uint32_t count) +static const VkPipelineTessellationStateCreateInfo *convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineTessellationStateCreateInfo32 *in, uint32_t count) { - VkPipelineColorBlendStateCreateInfo *out; + VkPipelineTessellationStateCreateInfo *out; unsigned int i;

if (!in || !count) return NULL; @@ -22701,28 +22474,128 @@ static inline const VkPipelineColorBlendStateCreateInfo *convert_VkPipelineColor out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]); + convert_VkPipelineTessellationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]); }

return out; }

-static inline void convert_VkPipelineDynamicStateCreateInfo_win32_to_host(const VkPipelineDynamicStateCreateInfo32 *in, VkPipelineDynamicStateCreateInfo *out) +static void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, VkPipelineViewportStateCreateInfo *out) { + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + if (!in) return;

out->sType = in->sType; out->pNext = NULL; out->flags = in->flags; - out->dynamicStateCount = in->dynamicStateCount; - out->pDynamicStates = UlongToPtr(in->pDynamicStates); - if (in->pNext) - FIXME("Unexpected pNext\n"); + out->viewportCount = in->viewportCount; + out->pViewports = UlongToPtr(in->pViewports); + out->scissorCount = in->scissorCount; + out->pScissors = UlongToPtr(in->pScissors); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: + { + VkPipelineViewportWScalingStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineViewportWScalingStateCreateInfoNV32 *in_ext = (const VkPipelineViewportWScalingStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV; + out_ext->pNext = NULL; + out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable; + out_ext->viewportCount = in_ext->viewportCount; + out_ext->pViewportWScalings = UlongToPtr(in_ext->pViewportWScalings); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: + { + VkPipelineViewportSwizzleStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineViewportSwizzleStateCreateInfoNV32 *in_ext = (const VkPipelineViewportSwizzleStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->viewportCount = in_ext->viewportCount; + out_ext->pViewportSwizzles = UlongToPtr(in_ext->pViewportSwizzles); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: + { + VkPipelineViewportExclusiveScissorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *in_ext = (const VkPipelineViewportExclusiveScissorStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV; + out_ext->pNext = NULL; + out_ext->exclusiveScissorCount = in_ext->exclusiveScissorCount; + out_ext->pExclusiveScissors = UlongToPtr(in_ext->pExclusiveScissors); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: + { + VkPipelineViewportShadingRateImageStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *in_ext = (const VkPipelineViewportShadingRateImageStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV; + out_ext->pNext = NULL; + out_ext->shadingRateImageEnable = in_ext->shadingRateImageEnable; + out_ext->viewportCount = in_ext->viewportCount; + out_ext->pShadingRatePalettes = convert_VkShadingRatePaletteNV_array_win32_to_host(ctx, (const VkShadingRatePaletteNV32 *)UlongToPtr(in_ext->pShadingRatePalettes), in_ext->viewportCount); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: + { + VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *in_ext = (const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV; + out_ext->pNext = NULL; + out_ext->sampleOrderType = in_ext->sampleOrderType; + out_ext->customSampleOrderCount = in_ext->customSampleOrderCount; + out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(in_ext->pCustomSampleOrders), in_ext->customSampleOrderCount); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: + { + VkPipelineViewportDepthClipControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineViewportDepthClipControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClipControlCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->negativeOneToOne = in_ext->negativeOneToOne; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + { + VkPipelineViewportDepthClampControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineViewportDepthClampControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClampControlCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->depthClampMode = in_ext->depthClampMode; + out_ext->pDepthClampRange = UlongToPtr(in_ext->pDepthClampRange); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } }

-static inline const VkPipelineDynamicStateCreateInfo *convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDynamicStateCreateInfo32 *in, uint32_t count) +static const VkPipelineViewportStateCreateInfo *convert_VkPipelineViewportStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineViewportStateCreateInfo32 *in, uint32_t count) { - VkPipelineDynamicStateCreateInfo *out; + VkPipelineViewportStateCreateInfo *out; unsigned int i;

if (!in || !count) return NULL; @@ -22730,16 +22603,15 @@ static inline const VkPipelineDynamicStateCreateInfo *convert_VkPipelineDynamicS out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkPipelineDynamicStateCreateInfo_win32_to_host(&in[i], &out[i]); + convert_VkPipelineViewportStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]); }

return out; }

-#ifdef _WIN64 -static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, VkGraphicsPipelineCreateInfo *out) +static void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, VkPipelineRasterizationStateCreateInfo *out) { - const VkBaseInStructure *in_header; + const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out;

if (!in) return; @@ -22747,236 +22619,302 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct con out->sType = in->sType; out->pNext = NULL; out->flags = in->flags; - out->stageCount = in->stageCount; - out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount); - out->pVertexInputState = in->pVertexInputState; - out->pInputAssemblyState = in->pInputAssemblyState; - out->pTessellationState = in->pTessellationState; - out->pViewportState = in->pViewportState; - out->pRasterizationState = in->pRasterizationState; - out->pMultisampleState = in->pMultisampleState; - out->pDepthStencilState = in->pDepthStencilState; - out->pColorBlendState = in->pColorBlendState; - out->pDynamicState = in->pDynamicState; - out->layout = in->layout; - out->renderPass = in->renderPass; - out->subpass = in->subpass; - out->basePipelineHandle = in->basePipelineHandle; - out->basePipelineIndex = in->basePipelineIndex; - - for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) - { - switch (in_header->sType) - { - case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: - { - VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCreateFlags2CreateInfo *in_ext = (const VkPipelineCreateFlags2CreateInfo *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; - out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: + out->depthClampEnable = in->depthClampEnable; + out->rasterizerDiscardEnable = in->rasterizerDiscardEnable; + out->polygonMode = in->polygonMode; + out->cullMode = in->cullMode; + out->frontFace = in->frontFace; + out->depthBiasEnable = in->depthBiasEnable; + out->depthBiasConstantFactor = in->depthBiasConstantFactor; + out->depthBiasClamp = in->depthBiasClamp; + out->depthBiasSlopeFactor = in->depthBiasSlopeFactor; + out->lineWidth = in->lineWidth; + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) { - VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineBinaryInfoKHR *in_ext = (const VkPipelineBinaryInfoKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: + { + VkPipelineRasterizationStateRasterizationOrderAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRasterizationStateRasterizationOrderAMD32 *in_ext = (const VkPipelineRasterizationStateRasterizationOrderAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; out_ext->pNext = NULL; - out_ext->binaryCount = in_ext->binaryCount; - out_ext->pPipelineBinaries = in_ext->pPipelineBinaries; + out_ext->rasterizationOrder = in_ext->rasterizationOrder; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: { - VkGraphicsPipelineShaderGroupsCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkGraphicsPipelineShaderGroupsCreateInfoNV *in_ext = (const VkGraphicsPipelineShaderGroupsCreateInfoNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV; + VkPipelineRasterizationConservativeStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationConservativeStateCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->groupCount = in_ext->groupCount; - out_ext->pGroups = convert_VkGraphicsShaderGroupCreateInfoNV_array_win64_to_host(ctx, in_ext->pGroups, in_ext->groupCount); - out_ext->pipelineCount = in_ext->pipelineCount; - out_ext->pPipelines = in_ext->pPipelines; + out_ext->flags = in_ext->flags; + out_ext->conservativeRasterizationMode = in_ext->conservativeRasterizationMode; + out_ext->extraPrimitiveOverestimationSize = in_ext->extraPrimitiveOverestimationSize; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: { - VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; + VkPipelineRasterizationStateStreamCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRasterizationStateStreamCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationStateStreamCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; out_ext->pNext = NULL; out_ext->flags = in_ext->flags; - out_ext->discardRectangleMode = in_ext->discardRectangleMode; - out_ext->discardRectangleCount = in_ext->discardRectangleCount; - out_ext->pDiscardRectangles = in_ext->pDiscardRectangles; + out_ext->rasterizationStream = in_ext->rasterizationStream; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: { - VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV; + VkPipelineRasterizationDepthClipStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationDepthClipStateCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable; + out_ext->flags = in_ext->flags; + out_ext->depthClipEnable = in_ext->depthClipEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: { - VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; + VkPipelineRasterizationLineStateCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRasterizationLineStateCreateInfo32 *in_ext = (const VkPipelineRasterizationLineStateCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO; out_ext->pNext = NULL; - out_ext->pPipelineCreationFeedback = in_ext->pPipelineCreationFeedback; - out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount; - out_ext->pPipelineStageCreationFeedbacks = in_ext->pPipelineStageCreationFeedbacks; + out_ext->lineRasterizationMode = in_ext->lineRasterizationMode; + out_ext->stippledLineEnable = in_ext->stippledLineEnable; + out_ext->lineStippleFactor = in_ext->lineStippleFactor; + out_ext->lineStipplePattern = in_ext->lineStipplePattern; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: { - VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; + VkPipelineRasterizationProvokingVertexStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->compilerControlFlags = in_ext->compilerControlFlags; + out_ext->provokingVertexMode = in_ext->provokingVertexMode; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: + case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: { - VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR; + VkDepthBiasRepresentationInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDepthBiasRepresentationInfoEXT32 *in_ext = (const VkDepthBiasRepresentationInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT; out_ext->pNext = NULL; - out_ext->libraryCount = in_ext->libraryCount; - out_ext->pLibraries = in_ext->pLibraries; + out_ext->depthBiasRepresentation = in_ext->depthBiasRepresentation; + out_ext->depthBiasExact = in_ext->depthBiasExact; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: - { - VkPipelineFragmentShadingRateStateCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineFragmentShadingRateStateCreateInfoKHR *in_ext = (const VkPipelineFragmentShadingRateStateCreateInfoKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR; - out_ext->pNext = NULL; - out_ext->fragmentSize = in_ext->fragmentSize; - memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR)); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; + default: + FIXME("Unhandled sType %u.\n", in_header->sType); break; } - case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: + } +} + +static const VkPipelineRasterizationStateCreateInfo *convert_VkPipelineRasterizationStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineRasterizationStateCreateInfo32 *in, uint32_t count) +{ + VkPipelineRasterizationStateCreateInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, VkPipelineMultisampleStateCreateInfo *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->rasterizationSamples = in->rasterizationSamples; + out->sampleShadingEnable = in->sampleShadingEnable; + out->minSampleShading = in->minSampleShading; + out->pSampleMask = UlongToPtr(in->pSampleMask); + out->alphaToCoverageEnable = in->alphaToCoverageEnable; + out->alphaToOneEnable = in->alphaToOneEnable; + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) { - VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: + { + VkPipelineCoverageToColorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCoverageToColorStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageToColorStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV; out_ext->pNext = NULL; - out_ext->shadingRateType = in_ext->shadingRateType; - out_ext->shadingRate = in_ext->shadingRate; - memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR)); + out_ext->flags = in_ext->flags; + out_ext->coverageToColorEnable = in_ext->coverageToColorEnable; + out_ext->coverageToColorLocation = in_ext->coverageToColorLocation; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: { - VkPipelineRenderingCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRenderingCreateInfo *in_ext = (const VkPipelineRenderingCreateInfo *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO; + VkPipelineSampleLocationsStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineSampleLocationsStateCreateInfoEXT32 *in_ext = (const VkPipelineSampleLocationsStateCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->viewMask = in_ext->viewMask; - out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; - out_ext->pColorAttachmentFormats = in_ext->pColorAttachmentFormats; - out_ext->depthAttachmentFormat = in_ext->depthAttachmentFormat; - out_ext->stencilAttachmentFormat = in_ext->stencilAttachmentFormat; + out_ext->sampleLocationsEnable = in_ext->sampleLocationsEnable; + convert_VkSampleLocationsInfoEXT_win32_to_host(&in_ext->sampleLocationsInfo, &out_ext->sampleLocationsInfo); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: { - VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; + VkPipelineCoverageModulationStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCoverageModulationStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageModulationStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV; out_ext->pNext = NULL; - out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; - out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples; - out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples; + out_ext->flags = in_ext->flags; + out_ext->coverageModulationMode = in_ext->coverageModulationMode; + out_ext->coverageModulationTableEnable = in_ext->coverageModulationTableEnable; + out_ext->coverageModulationTableCount = in_ext->coverageModulationTableCount; + out_ext->pCoverageModulationTable = UlongToPtr(in_ext->pCoverageModulationTable); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: { - VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; + VkPipelineCoverageReductionStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCoverageReductionStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageReductionStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV; out_ext->pNext = NULL; out_ext->flags = in_ext->flags; + out_ext->coverageReductionMode = in_ext->coverageReductionMode; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: - { - VkPipelineRobustnessCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRobustnessCreateInfo *in_ext = (const VkPipelineRobustnessCreateInfo *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO; - out_ext->pNext = NULL; - out_ext->storageBuffers = in_ext->storageBuffers; - out_ext->uniformBuffers = in_ext->uniformBuffers; - out_ext->vertexInputs = in_ext->vertexInputs; - out_ext->images = in_ext->images; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; + default: + FIXME("Unhandled sType %u.\n", in_header->sType); break; } - case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: + } +} + +static const VkPipelineMultisampleStateCreateInfo *convert_VkPipelineMultisampleStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineMultisampleStateCreateInfo32 *in, uint32_t count) +{ + VkPipelineMultisampleStateCreateInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(const VkPipelineDepthStencilStateCreateInfo32 *in, VkPipelineDepthStencilStateCreateInfo *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->depthTestEnable = in->depthTestEnable; + out->depthWriteEnable = in->depthWriteEnable; + out->depthCompareOp = in->depthCompareOp; + out->depthBoundsTestEnable = in->depthBoundsTestEnable; + out->stencilTestEnable = in->stencilTestEnable; + out->front = in->front; + out->back = in->back; + out->minDepthBounds = in->minDepthBounds; + out->maxDepthBounds = in->maxDepthBounds; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static const VkPipelineDepthStencilStateCreateInfo *convert_VkPipelineDepthStencilStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDepthStencilStateCreateInfo32 *in, uint32_t count) +{ + VkPipelineDepthStencilStateCreateInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkPipelineDepthStencilStateCreateInfo_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static void convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, VkPipelineColorBlendStateCreateInfo *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->logicOpEnable = in->logicOpEnable; + out->logicOp = in->logicOp; + out->attachmentCount = in->attachmentCount; + out->pAttachments = UlongToPtr(in->pAttachments); + memcpy(out->blendConstants, in->blendConstants, 4 * sizeof(float)); + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) { - VkRenderingAttachmentLocationInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRenderingAttachmentLocationInfo *in_ext = (const VkRenderingAttachmentLocationInfo *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO; - out_ext->pNext = NULL; - out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; - out_ext->pColorAttachmentLocations = in_ext->pColorAttachmentLocations; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: { - VkRenderingInputAttachmentIndexInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRenderingInputAttachmentIndexInfo *in_ext = (const VkRenderingInputAttachmentIndexInfo *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO; + VkPipelineColorBlendAdvancedStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *in_ext = (const VkPipelineColorBlendAdvancedStateCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; - out_ext->pColorAttachmentInputIndices = in_ext->pColorAttachmentInputIndices; - out_ext->pDepthInputAttachmentIndex = in_ext->pDepthInputAttachmentIndex; - out_ext->pStencilInputAttachmentIndex = in_ext->pStencilInputAttachmentIndex; + out_ext->srcPremultiplied = in_ext->srcPremultiplied; + out_ext->dstPremultiplied = in_ext->dstPremultiplied; + out_ext->blendOverlap = in_ext->blendOverlap; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: { - VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE; + VkPipelineColorWriteCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineColorWriteCreateInfoEXT32 *in_ext = (const VkPipelineColorWriteCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers; + out_ext->attachmentCount = in_ext->attachmentCount; + out_ext->pColorWriteEnables = UlongToPtr(in_ext->pColorWriteEnables); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22987,9 +22925,83 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct con } } } -#endif /* _WIN64 */

-static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, VkGraphicsPipelineCreateInfo *out) +static const VkPipelineColorBlendStateCreateInfo *convert_VkPipelineColorBlendStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineColorBlendStateCreateInfo32 *in, uint32_t count) +{ + VkPipelineColorBlendStateCreateInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkPipelineColorBlendStateCreateInfo_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkPipelineDynamicStateCreateInfo_win32_to_host(const VkPipelineDynamicStateCreateInfo32 *in, VkPipelineDynamicStateCreateInfo *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->flags = in->flags; + out->dynamicStateCount = in->dynamicStateCount; + out->pDynamicStates = UlongToPtr(in->pDynamicStates); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static const VkPipelineDynamicStateCreateInfo *convert_VkPipelineDynamicStateCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkPipelineDynamicStateCreateInfo32 *in, uint32_t count) +{ + VkPipelineDynamicStateCreateInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkPipelineDynamicStateCreateInfo_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static void convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, VkGraphicsShaderGroupCreateInfoNV *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->stageCount = in->stageCount; + out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win32_to_host(ctx, (const VkPipelineShaderStageCreateInfo32 *)UlongToPtr(in->pStages), in->stageCount); + out->pVertexInputState = convert_VkPipelineVertexInputStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineVertexInputStateCreateInfo32 *)UlongToPtr(in->pVertexInputState), 1); + out->pTessellationState = convert_VkPipelineTessellationStateCreateInfo_array_win32_to_host(ctx, (const VkPipelineTessellationStateCreateInfo32 *)UlongToPtr(in->pTessellationState), 1); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static const VkGraphicsShaderGroupCreateInfoNV *convert_VkGraphicsShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsShaderGroupCreateInfoNV32 *in, uint32_t count) +{ + VkGraphicsShaderGroupCreateInfoNV *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkGraphicsShaderGroupCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, VkGraphicsPipelineCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -23240,7 +23252,23 @@ static inline void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct con } }

-static inline void convert_VkGraphicsPipelineCreateInfo_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out) +static const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, uint32_t count) +{ + VkGraphicsPipelineCreateInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkGraphicsPipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkGraphicsPipelineCreateInfo_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -23268,41 +23296,7 @@ static inline void convert_VkGraphicsPipelineCreateInfo_host_to_win32(const VkGr } }

-#ifdef _WIN64 -static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo *in, uint32_t count) -{ - VkGraphicsPipelineCreateInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkGraphicsPipelineCreateInfo_win64_to_host(ctx, &in[i], &out[i]); - } - - return out; -} -#endif /* _WIN64 */ - -static inline const VkGraphicsPipelineCreateInfo *convert_VkGraphicsPipelineCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkGraphicsPipelineCreateInfo32 *in, uint32_t count) -{ - VkGraphicsPipelineCreateInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkGraphicsPipelineCreateInfo_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out, uint32_t count) +static void convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(const VkGraphicsPipelineCreateInfo *in, const VkGraphicsPipelineCreateInfo32 *out, uint32_t count) { unsigned int i;

@@ -23315,7 +23309,7 @@ static inline void convert_VkGraphicsPipelineCreateInfo_array_host_to_win32(cons }

#ifdef _WIN64 -static inline void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkImageCreateInfo *in, VkImageCreateInfo *out) +static void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *ctx, const VkImageCreateInfo *in, VkImageCreateInfo *out) { const VkBaseInStructure *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -23464,7 +23458,7 @@ static inline void convert_VkImageCreateInfo_win64_to_host(struct conversion_con } #endif /* _WIN64 */

-static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, VkImageCreateInfo *out) +static void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, VkImageCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -23612,7 +23606,7 @@ static inline void convert_VkImageCreateInfo_win32_to_host(struct conversion_con } }

-static inline void convert_VkImageViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageViewCreateInfo32 *in, VkImageViewCreateInfo *out) +static void convert_VkImageViewCreateInfo_win32_to_host(struct conversion_context *ctx, const VkImageViewCreateInfo32 *in, VkImageViewCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -23719,7 +23713,7 @@ static inline void convert_VkImageViewCreateInfo_win32_to_host(struct conversion } }

-static inline void convert_VkIndirectCommandsTokenDataEXT_win32_to_host(const VkIndirectCommandsTokenDataEXT32 *in, VkIndirectCommandsTokenDataEXT *out, VkFlags selector) +static void convert_VkIndirectCommandsTokenDataEXT_win32_to_host(const VkIndirectCommandsTokenDataEXT32 *in, VkIndirectCommandsTokenDataEXT *out, VkFlags selector) { if (!in) return;

@@ -23733,7 +23727,7 @@ static inline void convert_VkIndirectCommandsTokenDataEXT_win32_to_host(const Vk out->pExecutionSet = UlongToPtr(in->pExecutionSet); }

-static inline void convert_VkIndirectCommandsLayoutTokenEXT_win32_to_host(const VkIndirectCommandsLayoutTokenEXT32 *in, VkIndirectCommandsLayoutTokenEXT *out) +static void convert_VkIndirectCommandsLayoutTokenEXT_win32_to_host(const VkIndirectCommandsLayoutTokenEXT32 *in, VkIndirectCommandsLayoutTokenEXT *out) { if (!in) return;

@@ -23746,7 +23740,7 @@ static inline void convert_VkIndirectCommandsLayoutTokenEXT_win32_to_host(const FIXME("Unexpected pNext\n"); }

-static inline const VkIndirectCommandsLayoutTokenEXT *convert_VkIndirectCommandsLayoutTokenEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenEXT32 *in, uint32_t count) +static const VkIndirectCommandsLayoutTokenEXT *convert_VkIndirectCommandsLayoutTokenEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenEXT32 *in, uint32_t count) { VkIndirectCommandsLayoutTokenEXT *out; unsigned int i; @@ -23762,7 +23756,7 @@ static inline const VkIndirectCommandsLayoutTokenEXT *convert_VkIndirectCommands return out; }

-static inline void convert_VkIndirectCommandsLayoutCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoEXT32 *in, VkIndirectCommandsLayoutCreateInfoEXT *out) +static void convert_VkIndirectCommandsLayoutCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoEXT32 *in, VkIndirectCommandsLayoutCreateInfoEXT *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -23804,7 +23798,7 @@ static inline void convert_VkIndirectCommandsLayoutCreateInfoEXT_win32_to_host(s } }

-static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const VkIndirectCommandsLayoutTokenNV32 *in, VkIndirectCommandsLayoutTokenNV *out) +static void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const VkIndirectCommandsLayoutTokenNV32 *in, VkIndirectCommandsLayoutTokenNV *out) { if (!in) return;

@@ -23827,7 +23821,7 @@ static inline void convert_VkIndirectCommandsLayoutTokenNV_win32_to_host(const V FIXME("Unexpected pNext\n"); }

-static inline const VkIndirectCommandsLayoutTokenNV *convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenNV32 *in, uint32_t count) +static const VkIndirectCommandsLayoutTokenNV *convert_VkIndirectCommandsLayoutTokenNV_array_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutTokenNV32 *in, uint32_t count) { VkIndirectCommandsLayoutTokenNV *out; unsigned int i; @@ -23843,7 +23837,7 @@ static inline const VkIndirectCommandsLayoutTokenNV *convert_VkIndirectCommandsL return out; }

-static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoNV32 *in, VkIndirectCommandsLayoutCreateInfoNV *out) +static void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkIndirectCommandsLayoutCreateInfoNV32 *in, VkIndirectCommandsLayoutCreateInfoNV *out) { if (!in) return;

@@ -23859,7 +23853,7 @@ static inline void convert_VkIndirectCommandsLayoutCreateInfoNV_win32_to_host(st FIXME("Unexpected pNext\n"); }

-static inline void convert_VkIndirectExecutionSetPipelineInfoEXT_win32_to_host(const VkIndirectExecutionSetPipelineInfoEXT32 *in, VkIndirectExecutionSetPipelineInfoEXT *out) +static void convert_VkIndirectExecutionSetPipelineInfoEXT_win32_to_host(const VkIndirectExecutionSetPipelineInfoEXT32 *in, VkIndirectExecutionSetPipelineInfoEXT *out) { if (!in) return;

@@ -23871,7 +23865,7 @@ static inline void convert_VkIndirectExecutionSetPipelineInfoEXT_win32_to_host(c FIXME("Unexpected pNext\n"); }

-static inline const VkIndirectExecutionSetPipelineInfoEXT *convert_VkIndirectExecutionSetPipelineInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetPipelineInfoEXT32 *in, uint32_t count) +static const VkIndirectExecutionSetPipelineInfoEXT *convert_VkIndirectExecutionSetPipelineInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetPipelineInfoEXT32 *in, uint32_t count) { VkIndirectExecutionSetPipelineInfoEXT *out; unsigned int i; @@ -23887,7 +23881,7 @@ static inline const VkIndirectExecutionSetPipelineInfoEXT *convert_VkIndirectExe return out; }

-static inline void convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_host(const VkIndirectExecutionSetShaderLayoutInfoEXT32 *in, VkIndirectExecutionSetShaderLayoutInfoEXT *out) +static void convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_host(const VkIndirectExecutionSetShaderLayoutInfoEXT32 *in, VkIndirectExecutionSetShaderLayoutInfoEXT *out) { if (!in) return;

@@ -23895,94 +23889,13 @@ static inline void convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_ho out->pNext = NULL; out->setLayoutCount = in->setLayoutCount; out->pSetLayouts = UlongToPtr(in->pSetLayouts); - if (in->pNext) - FIXME("Unexpected pNext\n"); -} - -static inline const VkIndirectExecutionSetShaderLayoutInfoEXT *convert_VkIndirectExecutionSetShaderLayoutInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderLayoutInfoEXT32 *in, uint32_t count) -{ - VkIndirectExecutionSetShaderLayoutInfoEXT *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_host(&in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkIndirectExecutionSetShaderInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderInfoEXT32 *in, VkIndirectExecutionSetShaderInfoEXT *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->shaderCount = in->shaderCount; - out->pInitialShaders = UlongToPtr(in->pInitialShaders); - out->pSetLayoutInfos = convert_VkIndirectExecutionSetShaderLayoutInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetShaderLayoutInfoEXT32 *)UlongToPtr(in->pSetLayoutInfos), in->shaderCount); - out->maxShaderCount = in->maxShaderCount; - out->pushConstantRangeCount = in->pushConstantRangeCount; - out->pPushConstantRanges = UlongToPtr(in->pPushConstantRanges); - if (in->pNext) - FIXME("Unexpected pNext\n"); -} - -static inline const VkIndirectExecutionSetShaderInfoEXT *convert_VkIndirectExecutionSetShaderInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderInfoEXT32 *in, uint32_t count) -{ - VkIndirectExecutionSetShaderInfoEXT *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkIndirectExecutionSetShaderInfoEXT_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkIndirectExecutionSetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetInfoEXT32 *in, VkIndirectExecutionSetInfoEXT *out, VkFlags selector) -{ - if (!in) return; - - if (selector == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT) - out->pPipelineInfo = convert_VkIndirectExecutionSetPipelineInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetPipelineInfoEXT32 *)UlongToPtr(in->pPipelineInfo), 1); - if (selector == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT) - out->pShaderInfo = convert_VkIndirectExecutionSetShaderInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetShaderInfoEXT32 *)UlongToPtr(in->pShaderInfo), 1); -} - -static inline void convert_VkIndirectExecutionSetCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetCreateInfoEXT32 *in, VkIndirectExecutionSetCreateInfoEXT *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->type = in->type; - convert_VkIndirectExecutionSetInfoEXT_win32_to_host(ctx, &in->info, &out->info, in->type); - if (in->pNext) - FIXME("Unexpected pNext\n"); -} - -static inline void convert_VkLayerSettingEXT_win32_to_host(const VkLayerSettingEXT32 *in, VkLayerSettingEXT *out) -{ - if (!in) return; - - out->pLayerName = UlongToPtr(in->pLayerName); - out->pSettingName = UlongToPtr(in->pSettingName); - out->type = in->type; - out->valueCount = in->valueCount; - out->pValues = UlongToPtr(in->pValues); + if (in->pNext) + FIXME("Unexpected pNext\n"); }

-static inline const VkLayerSettingEXT *convert_VkLayerSettingEXT_array_win32_to_host(struct conversion_context *ctx, const VkLayerSettingEXT32 *in, uint32_t count) +static const VkIndirectExecutionSetShaderLayoutInfoEXT *convert_VkIndirectExecutionSetShaderLayoutInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderLayoutInfoEXT32 *in, uint32_t count) { - VkLayerSettingEXT *out; + VkIndirectExecutionSetShaderLayoutInfoEXT *out; unsigned int i;

if (!in || !count) return NULL; @@ -23990,30 +23903,31 @@ static inline const VkLayerSettingEXT *convert_VkLayerSettingEXT_array_win32_to_ out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkLayerSettingEXT_win32_to_host(&in[i], &out[i]); + convert_VkIndirectExecutionSetShaderLayoutInfoEXT_win32_to_host(&in[i], &out[i]); }

return out; }

-static inline void convert_VkApplicationInfo_win32_to_host(const VkApplicationInfo32 *in, VkApplicationInfo *out) +static void convert_VkIndirectExecutionSetShaderInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderInfoEXT32 *in, VkIndirectExecutionSetShaderInfoEXT *out) { if (!in) return;

out->sType = in->sType; out->pNext = NULL; - out->pApplicationName = UlongToPtr(in->pApplicationName); - out->applicationVersion = in->applicationVersion; - out->pEngineName = UlongToPtr(in->pEngineName); - out->engineVersion = in->engineVersion; - out->apiVersion = in->apiVersion; + out->shaderCount = in->shaderCount; + out->pInitialShaders = UlongToPtr(in->pInitialShaders); + out->pSetLayoutInfos = convert_VkIndirectExecutionSetShaderLayoutInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetShaderLayoutInfoEXT32 *)UlongToPtr(in->pSetLayoutInfos), in->shaderCount); + out->maxShaderCount = in->maxShaderCount; + out->pushConstantRangeCount = in->pushConstantRangeCount; + out->pPushConstantRanges = UlongToPtr(in->pPushConstantRanges); if (in->pNext) FIXME("Unexpected pNext\n"); }

-static inline const VkApplicationInfo *convert_VkApplicationInfo_array_win32_to_host(struct conversion_context *ctx, const VkApplicationInfo32 *in, uint32_t count) +static const VkIndirectExecutionSetShaderInfoEXT *convert_VkIndirectExecutionSetShaderInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetShaderInfoEXT32 *in, uint32_t count) { - VkApplicationInfo *out; + VkIndirectExecutionSetShaderInfoEXT *out; unsigned int i;

if (!in || !count) return NULL; @@ -24021,14 +23935,36 @@ static inline const VkApplicationInfo *convert_VkApplicationInfo_array_win32_to_ out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkApplicationInfo_win32_to_host(&in[i], &out[i]); + convert_VkIndirectExecutionSetShaderInfoEXT_win32_to_host(ctx, &in[i], &out[i]); }

return out; }

+static void convert_VkIndirectExecutionSetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetInfoEXT32 *in, VkIndirectExecutionSetInfoEXT *out, VkFlags selector) +{ + if (!in) return; + + if (selector == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT) + out->pPipelineInfo = convert_VkIndirectExecutionSetPipelineInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetPipelineInfoEXT32 *)UlongToPtr(in->pPipelineInfo), 1); + if (selector == VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT) + out->pShaderInfo = convert_VkIndirectExecutionSetShaderInfoEXT_array_win32_to_host(ctx, (const VkIndirectExecutionSetShaderInfoEXT32 *)UlongToPtr(in->pShaderInfo), 1); +} + +static void convert_VkIndirectExecutionSetCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkIndirectExecutionSetCreateInfoEXT32 *in, VkIndirectExecutionSetCreateInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->type = in->type; + convert_VkIndirectExecutionSetInfoEXT_win32_to_host(ctx, &in->info, &out->info, in->type); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + #ifdef _WIN64 -static inline void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo *in, VkInstanceCreateInfo *out) +static void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo *in, VkInstanceCreateInfo *out) { const VkBaseInStructure *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -24124,7 +24060,65 @@ static inline void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_ } #endif /* _WIN64 */

-static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo32 *in, VkInstanceCreateInfo *out) +static void convert_VkApplicationInfo_win32_to_host(const VkApplicationInfo32 *in, VkApplicationInfo *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->pApplicationName = UlongToPtr(in->pApplicationName); + out->applicationVersion = in->applicationVersion; + out->pEngineName = UlongToPtr(in->pEngineName); + out->engineVersion = in->engineVersion; + out->apiVersion = in->apiVersion; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static const VkApplicationInfo *convert_VkApplicationInfo_array_win32_to_host(struct conversion_context *ctx, const VkApplicationInfo32 *in, uint32_t count) +{ + VkApplicationInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkApplicationInfo_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static void convert_VkLayerSettingEXT_win32_to_host(const VkLayerSettingEXT32 *in, VkLayerSettingEXT *out) +{ + if (!in) return; + + out->pLayerName = UlongToPtr(in->pLayerName); + out->pSettingName = UlongToPtr(in->pSettingName); + out->type = in->type; + out->valueCount = in->valueCount; + out->pValues = UlongToPtr(in->pValues); +} + +static const VkLayerSettingEXT *convert_VkLayerSettingEXT_array_win32_to_host(struct conversion_context *ctx, const VkLayerSettingEXT32 *in, uint32_t count) +{ + VkLayerSettingEXT *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkLayerSettingEXT_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context *ctx, const VkInstanceCreateInfo32 *in, VkInstanceCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -24219,7 +24213,7 @@ static inline void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_ } }

-static inline void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicromapCreateInfoEXT32 *in, VkMicromapCreateInfoEXT *out) +static void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicromapCreateInfoEXT32 *in, VkMicromapCreateInfoEXT *out) { if (!in) return;

@@ -24235,7 +24229,7 @@ static inline void convert_VkMicromapCreateInfoEXT_win32_to_host(const VkMicroma FIXME("Unexpected pNext\n"); }

-static inline void convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowSessionCreateInfoNV32 *in, VkOpticalFlowSessionCreateInfoNV *out) +static void convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowSessionCreateInfoNV32 *in, VkOpticalFlowSessionCreateInfoNV *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -24278,7 +24272,7 @@ static inline void convert_VkOpticalFlowSessionCreateInfoNV_win32_to_host(struct } }

-static inline void convert_VkPipelineBinaryKeyKHR_win32_to_host(const VkPipelineBinaryKeyKHR32 *in, VkPipelineBinaryKeyKHR *out) +static void convert_VkPipelineBinaryKeyKHR_win32_to_host(const VkPipelineBinaryKeyKHR32 *in, VkPipelineBinaryKeyKHR *out) { if (!in) return;

@@ -24290,7 +24284,7 @@ static inline void convert_VkPipelineBinaryKeyKHR_win32_to_host(const VkPipeline FIXME("Unexpected pNext\n"); }

-static inline const VkPipelineBinaryKeyKHR *convert_VkPipelineBinaryKeyKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeyKHR32 *in, uint32_t count) +static const VkPipelineBinaryKeyKHR *convert_VkPipelineBinaryKeyKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeyKHR32 *in, uint32_t count) { VkPipelineBinaryKeyKHR *out; unsigned int i; @@ -24306,7 +24300,7 @@ static inline const VkPipelineBinaryKeyKHR *convert_VkPipelineBinaryKeyKHR_array return out; }

-static inline void convert_VkPipelineBinaryDataKHR_win32_to_host(const VkPipelineBinaryDataKHR32 *in, VkPipelineBinaryDataKHR *out) +static void convert_VkPipelineBinaryDataKHR_win32_to_host(const VkPipelineBinaryDataKHR32 *in, VkPipelineBinaryDataKHR *out) { if (!in) return;

@@ -24314,7 +24308,7 @@ static inline void convert_VkPipelineBinaryDataKHR_win32_to_host(const VkPipelin out->pData = UlongToPtr(in->pData); }

-static inline const VkPipelineBinaryDataKHR *convert_VkPipelineBinaryDataKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryDataKHR32 *in, uint32_t count) +static const VkPipelineBinaryDataKHR *convert_VkPipelineBinaryDataKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryDataKHR32 *in, uint32_t count) { VkPipelineBinaryDataKHR *out; unsigned int i; @@ -24330,7 +24324,7 @@ static inline const VkPipelineBinaryDataKHR *convert_VkPipelineBinaryDataKHR_arr return out; }

-static inline void convert_VkPipelineBinaryKeysAndDataKHR_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeysAndDataKHR32 *in, VkPipelineBinaryKeysAndDataKHR *out) +static void convert_VkPipelineBinaryKeysAndDataKHR_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeysAndDataKHR32 *in, VkPipelineBinaryKeysAndDataKHR *out) { if (!in) return;

@@ -24339,7 +24333,7 @@ static inline void convert_VkPipelineBinaryKeysAndDataKHR_win32_to_host(struct c out->pPipelineBinaryData = convert_VkPipelineBinaryDataKHR_array_win32_to_host(ctx, (const VkPipelineBinaryDataKHR32 *)UlongToPtr(in->pPipelineBinaryData), in->binaryCount); }

-static inline const VkPipelineBinaryKeysAndDataKHR *convert_VkPipelineBinaryKeysAndDataKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeysAndDataKHR32 *in, uint32_t count) +static const VkPipelineBinaryKeysAndDataKHR *convert_VkPipelineBinaryKeysAndDataKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryKeysAndDataKHR32 *in, uint32_t count) { VkPipelineBinaryKeysAndDataKHR *out; unsigned int i; @@ -24355,7 +24349,7 @@ static inline const VkPipelineBinaryKeysAndDataKHR *convert_VkPipelineBinaryKeys return out; }

-static inline void convert_VkPipelineCreateInfoKHR_win32_to_host(const VkPipelineCreateInfoKHR32 *in, VkPipelineCreateInfoKHR *out) +static void convert_VkPipelineCreateInfoKHR_win32_to_host(const VkPipelineCreateInfoKHR32 *in, VkPipelineCreateInfoKHR *out) { if (!in) return;

@@ -24365,7 +24359,7 @@ static inline void convert_VkPipelineCreateInfoKHR_win32_to_host(const VkPipelin FIXME("Unexpected pNext\n"); }

-static inline const VkPipelineCreateInfoKHR *convert_VkPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreateInfoKHR32 *in, uint32_t count) +static const VkPipelineCreateInfoKHR *convert_VkPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineCreateInfoKHR32 *in, uint32_t count) { VkPipelineCreateInfoKHR *out; unsigned int i; @@ -24381,7 +24375,7 @@ static inline const VkPipelineCreateInfoKHR *convert_VkPipelineCreateInfoKHR_arr return out; }

-static inline void convert_VkPipelineBinaryCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryCreateInfoKHR32 *in, VkPipelineBinaryCreateInfoKHR *out) +static void convert_VkPipelineBinaryCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPipelineBinaryCreateInfoKHR32 *in, VkPipelineBinaryCreateInfoKHR *out) { if (!in) return;

@@ -24394,7 +24388,7 @@ static inline void convert_VkPipelineBinaryCreateInfoKHR_win32_to_host(struct co FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPipelineBinaryHandlesInfoKHR_win32_to_host(const VkPipelineBinaryHandlesInfoKHR32 *in, VkPipelineBinaryHandlesInfoKHR *out) +static void convert_VkPipelineBinaryHandlesInfoKHR_win32_to_host(const VkPipelineBinaryHandlesInfoKHR32 *in, VkPipelineBinaryHandlesInfoKHR *out) { if (!in) return;

@@ -24406,7 +24400,7 @@ static inline void convert_VkPipelineBinaryHandlesInfoKHR_win32_to_host(const Vk FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPipelineBinaryHandlesInfoKHR_host_to_win32(const VkPipelineBinaryHandlesInfoKHR *in, VkPipelineBinaryHandlesInfoKHR32 *out) +static void convert_VkPipelineBinaryHandlesInfoKHR_host_to_win32(const VkPipelineBinaryHandlesInfoKHR *in, VkPipelineBinaryHandlesInfoKHR32 *out) { if (!in) return;

@@ -24414,7 +24408,7 @@ static inline void convert_VkPipelineBinaryHandlesInfoKHR_host_to_win32(const Vk out->pPipelineBinaries = PtrToUlong(in->pPipelineBinaries); }

-static inline void convert_VkPipelineCacheCreateInfo_win32_to_host(const VkPipelineCacheCreateInfo32 *in, VkPipelineCacheCreateInfo *out) +static void convert_VkPipelineCacheCreateInfo_win32_to_host(const VkPipelineCacheCreateInfo32 *in, VkPipelineCacheCreateInfo *out) { if (!in) return;

@@ -24427,7 +24421,7 @@ static inline void convert_VkPipelineCacheCreateInfo_win32_to_host(const VkPipel FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPipelineLayoutCreateInfo_win32_to_host(const VkPipelineLayoutCreateInfo32 *in, VkPipelineLayoutCreateInfo *out) +static void convert_VkPipelineLayoutCreateInfo_win32_to_host(const VkPipelineLayoutCreateInfo32 *in, VkPipelineLayoutCreateInfo *out) { if (!in) return;

@@ -24442,7 +24436,7 @@ static inline void convert_VkPipelineLayoutCreateInfo_win32_to_host(const VkPipe FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPrivateDataSlotCreateInfo_win32_to_host(const VkPrivateDataSlotCreateInfo32 *in, VkPrivateDataSlotCreateInfo *out) +static void convert_VkPrivateDataSlotCreateInfo_win32_to_host(const VkPrivateDataSlotCreateInfo32 *in, VkPrivateDataSlotCreateInfo *out) { if (!in) return;

@@ -24453,7 +24447,7 @@ static inline void convert_VkPrivateDataSlotCreateInfo_win32_to_host(const VkPri FIXME("Unexpected pNext\n"); }

-static inline void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkQueryPoolCreateInfo32 *in, VkQueryPoolCreateInfo *out) +static void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_context *ctx, const VkQueryPoolCreateInfo32 *in, VkQueryPoolCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -24608,7 +24602,47 @@ static inline void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion } }

-static inline void convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(const VkRayTracingShaderGroupCreateInfoKHR32 *in, VkRayTracingShaderGroupCreateInfoKHR *out) +#ifdef _WIN64 +static void convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, VkRayTracingPipelineCreateInfoKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->flags = in->flags; + out->stageCount = in->stageCount; + out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount); + out->groupCount = in->groupCount; + out->pGroups = in->pGroups; + out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth; + out->pLibraryInfo = in->pLibraryInfo; + out->pLibraryInterface = in->pLibraryInterface; + out->pDynamicState = in->pDynamicState; + out->layout = in->layout; + out->basePipelineHandle = in->basePipelineHandle; + out->basePipelineIndex = in->basePipelineIndex; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, uint32_t count) +{ + VkRayTracingPipelineCreateInfoKHR *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(ctx, &in[i], &out[i]); + } + + return out; +} +#endif /* _WIN64 */ + +static void convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(const VkRayTracingShaderGroupCreateInfoKHR32 *in, VkRayTracingShaderGroupCreateInfoKHR *out) { if (!in) return;

@@ -24624,7 +24658,7 @@ static inline void convert_VkRayTracingShaderGroupCreateInfoKHR_win32_to_host(co FIXME("Unexpected pNext\n"); }

-static inline const VkRayTracingShaderGroupCreateInfoKHR *convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoKHR32 *in, uint32_t count) +static const VkRayTracingShaderGroupCreateInfoKHR *convert_VkRayTracingShaderGroupCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoKHR32 *in, uint32_t count) { VkRayTracingShaderGroupCreateInfoKHR *out; unsigned int i; @@ -24640,7 +24674,7 @@ static inline const VkRayTracingShaderGroupCreateInfoKHR *convert_VkRayTracingSh return out; }

-static inline void convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(const VkPipelineLibraryCreateInfoKHR32 *in, VkPipelineLibraryCreateInfoKHR *out) +static void convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(const VkPipelineLibraryCreateInfoKHR32 *in, VkPipelineLibraryCreateInfoKHR *out) { if (!in) return;

@@ -24652,7 +24686,7 @@ static inline void convert_VkPipelineLibraryCreateInfoKHR_win32_to_host(const Vk FIXME("Unexpected pNext\n"); }

-static inline const VkPipelineLibraryCreateInfoKHR *convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineLibraryCreateInfoKHR32 *in, uint32_t count) +static const VkPipelineLibraryCreateInfoKHR *convert_VkPipelineLibraryCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineLibraryCreateInfoKHR32 *in, uint32_t count) { VkPipelineLibraryCreateInfoKHR *out; unsigned int i; @@ -24668,7 +24702,7 @@ static inline const VkPipelineLibraryCreateInfoKHR *convert_VkPipelineLibraryCre return out; }

-static inline void convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, VkRayTracingPipelineInterfaceCreateInfoKHR *out) +static void convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_host(const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, VkRayTracingPipelineInterfaceCreateInfoKHR *out) { if (!in) return;

@@ -24680,7 +24714,7 @@ static inline void convert_VkRayTracingPipelineInterfaceCreateInfoKHR_win32_to_h FIXME("Unexpected pNext\n"); }

-static inline const VkRayTracingPipelineInterfaceCreateInfoKHR *convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, uint32_t count) +static const VkRayTracingPipelineInterfaceCreateInfoKHR *convert_VkRayTracingPipelineInterfaceCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineInterfaceCreateInfoKHR32 *in, uint32_t count) { VkRayTracingPipelineInterfaceCreateInfoKHR *out; unsigned int i; @@ -24696,29 +24730,7 @@ static inline const VkRayTracingPipelineInterfaceCreateInfoKHR *convert_VkRayTra return out; }

-#ifdef _WIN64 -static inline void convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, VkRayTracingPipelineCreateInfoKHR *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = in->pNext; - out->flags = in->flags; - out->stageCount = in->stageCount; - out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount); - out->groupCount = in->groupCount; - out->pGroups = in->pGroups; - out->maxPipelineRayRecursionDepth = in->maxPipelineRayRecursionDepth; - out->pLibraryInfo = in->pLibraryInfo; - out->pLibraryInterface = in->pLibraryInterface; - out->pDynamicState = in->pDynamicState; - out->layout = in->layout; - out->basePipelineHandle = in->basePipelineHandle; - out->basePipelineIndex = in->basePipelineIndex; -} -#endif /* _WIN64 */ - -static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, VkRayTracingPipelineCreateInfoKHR *out) +static void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, VkRayTracingPipelineCreateInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -24812,7 +24824,23 @@ static inline void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struc } }

-static inline void convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out) +static const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, uint32_t count) +{ + VkRayTracingPipelineCreateInfoKHR *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -24840,27 +24868,41 @@ static inline void convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(const } }

-#ifdef _WIN64 -static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR *in, uint32_t count) +static void convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out, uint32_t count) { - VkRayTracingPipelineCreateInfoKHR *out; unsigned int i;

- if (!in || !count) return NULL; + if (!in) return;

- out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkRayTracingPipelineCreateInfoKHR_win64_to_host(ctx, &in[i], &out[i]); + convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(&in[i], &out[i]); } +}

- return out; +#ifdef _WIN64 +static void convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, VkRayTracingPipelineCreateInfoNV *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->flags = in->flags; + out->stageCount = in->stageCount; + out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount); + out->groupCount = in->groupCount; + out->pGroups = in->pGroups; + out->maxRecursionDepth = in->maxRecursionDepth; + out->layout = in->layout; + out->basePipelineHandle = in->basePipelineHandle; + out->basePipelineIndex = in->basePipelineIndex; } #endif /* _WIN64 */

-static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipelineCreateInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoKHR32 *in, uint32_t count) +#ifdef _WIN64 +static const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, uint32_t count) { - VkRayTracingPipelineCreateInfoKHR *out; + VkRayTracingPipelineCreateInfoNV *out; unsigned int i;

if (!in || !count) return NULL; @@ -24868,25 +24910,14 @@ static inline const VkRayTracingPipelineCreateInfoKHR *convert_VkRayTracingPipel out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(ctx, &in[i], &out[i]); + convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]); }

return out; } +#endif /* _WIN64 */

-static inline void convert_VkRayTracingPipelineCreateInfoKHR_array_host_to_win32(const VkRayTracingPipelineCreateInfoKHR *in, const VkRayTracingPipelineCreateInfoKHR32 *out, uint32_t count) -{ - unsigned int i; - - if (!in) return; - - for (i = 0; i < count; i++) - { - convert_VkRayTracingPipelineCreateInfoKHR_host_to_win32(&in[i], &out[i]); - } -} - -static inline void convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(const VkRayTracingShaderGroupCreateInfoNV32 *in, VkRayTracingShaderGroupCreateInfoNV *out) +static void convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(const VkRayTracingShaderGroupCreateInfoNV32 *in, VkRayTracingShaderGroupCreateInfoNV *out) { if (!in) return;

@@ -24901,7 +24932,7 @@ static inline void convert_VkRayTracingShaderGroupCreateInfoNV_win32_to_host(con FIXME("Unexpected pNext\n"); }

-static inline const VkRayTracingShaderGroupCreateInfoNV *convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoNV32 *in, uint32_t count) +static const VkRayTracingShaderGroupCreateInfoNV *convert_VkRayTracingShaderGroupCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingShaderGroupCreateInfoNV32 *in, uint32_t count) { VkRayTracingShaderGroupCreateInfoNV *out; unsigned int i; @@ -24917,26 +24948,7 @@ static inline const VkRayTracingShaderGroupCreateInfoNV *convert_VkRayTracingSha return out; }

-#ifdef _WIN64 -static inline void convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, VkRayTracingPipelineCreateInfoNV *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = in->pNext; - out->flags = in->flags; - out->stageCount = in->stageCount; - out->pStages = convert_VkPipelineShaderStageCreateInfo_array_win64_to_host(ctx, in->pStages, in->stageCount); - out->groupCount = in->groupCount; - out->pGroups = in->pGroups; - out->maxRecursionDepth = in->maxRecursionDepth; - out->layout = in->layout; - out->basePipelineHandle = in->basePipelineHandle; - out->basePipelineIndex = in->basePipelineIndex; -} -#endif /* _WIN64 */ - -static inline void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, VkRayTracingPipelineCreateInfoNV *out) +static void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, VkRayTracingPipelineCreateInfoNV *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -24984,42 +24996,13 @@ static inline void convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(struct break; } default: - FIXME("Unhandled sType %u.\n", in_header->sType); - break; - } - } -} - -static inline void convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out) -{ - const VkBaseInStructure *in_header; - VkBaseOutStructure32 *out_header = (void *)out; - - if (!in) return; - - - for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) - { - switch (in_header->sType) - { - case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: - { - VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO); - const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; - convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1); - convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount); - out_header = (void *)out_ext; - break; - } - default: + FIXME("Unhandled sType %u.\n", in_header->sType); break; } } }

-#ifdef _WIN64 -static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win64_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV *in, uint32_t count) +static const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, uint32_t count) { VkRayTracingPipelineCreateInfoNV *out; unsigned int i; @@ -25029,30 +25012,41 @@ static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipeli out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkRayTracingPipelineCreateInfoNV_win64_to_host(ctx, &in[i], &out[i]); + convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]); }

return out; } -#endif /* _WIN64 */

-static inline const VkRayTracingPipelineCreateInfoNV *convert_VkRayTracingPipelineCreateInfoNV_array_win32_to_host(struct conversion_context *ctx, const VkRayTracingPipelineCreateInfoNV32 *in, uint32_t count) +static void convert_VkRayTracingPipelineCreateInfoNV_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out) { - VkRayTracingPipelineCreateInfoNV *out; - unsigned int i; + const VkBaseInStructure *in_header; + VkBaseOutStructure32 *out_header = (void *)out;

- if (!in || !count) return NULL; + if (!in) return;

- out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) + + for (in_header = (void *)in->pNext; in_header; in_header = (void *)in_header->pNext) { - convert_VkRayTracingPipelineCreateInfoNV_win32_to_host(ctx, &in[i], &out[i]); + switch (in_header->sType) + { + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + { + VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO); + const VkPipelineCreationFeedbackCreateInfo *in_ext = (const VkPipelineCreationFeedbackCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; + convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineCreationFeedback, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineCreationFeedback), 1); + convert_VkPipelineCreationFeedback_array_host_to_win32(in_ext->pPipelineStageCreationFeedbacks, (VkPipelineCreationFeedback32 *)UlongToPtr(out_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount); + out_header = (void *)out_ext; + break; + } + default: + break; + } } - - return out; }

-static inline void convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out, uint32_t count) +static void convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32(const VkRayTracingPipelineCreateInfoNV *in, const VkRayTracingPipelineCreateInfoNV32 *out, uint32_t count) { unsigned int i;

@@ -25064,7 +25058,7 @@ static inline void convert_VkRayTracingPipelineCreateInfoNV_array_host_to_win32( } }

-static inline void convert_VkSubpassDescription_win32_to_host(const VkSubpassDescription32 *in, VkSubpassDescription *out) +static void convert_VkSubpassDescription_win32_to_host(const VkSubpassDescription32 *in, VkSubpassDescription *out) { if (!in) return;

@@ -25080,7 +25074,7 @@ static inline void convert_VkSubpassDescription_win32_to_host(const VkSubpassDes out->pPreserveAttachments = UlongToPtr(in->pPreserveAttachments); }

-static inline const VkSubpassDescription *convert_VkSubpassDescription_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription32 *in, uint32_t count) +static const VkSubpassDescription *convert_VkSubpassDescription_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription32 *in, uint32_t count) { VkSubpassDescription *out; unsigned int i; @@ -25096,7 +25090,7 @@ static inline const VkSubpassDescription *convert_VkSubpassDescription_array_win return out; }

-static inline void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo32 *in, VkRenderPassCreateInfo *out) +static void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo32 *in, VkRenderPassCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -25186,7 +25180,7 @@ static inline void convert_VkRenderPassCreateInfo_win32_to_host(struct conversio } }

-static inline void convert_VkAttachmentDescription2_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, VkAttachmentDescription2 *out) +static void convert_VkAttachmentDescription2_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, VkAttachmentDescription2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -25228,7 +25222,7 @@ static inline void convert_VkAttachmentDescription2_win32_to_host(struct convers } }

-static inline const VkAttachmentDescription2 *convert_VkAttachmentDescription2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, uint32_t count) +static const VkAttachmentDescription2 *convert_VkAttachmentDescription2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentDescription232 *in, uint32_t count) { VkAttachmentDescription2 *out; unsigned int i; @@ -25244,7 +25238,7 @@ static inline const VkAttachmentDescription2 *convert_VkAttachmentDescription2_a return out; }

-static inline void convert_VkAttachmentReference2_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, VkAttachmentReference2 *out) +static void convert_VkAttachmentReference2_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, VkAttachmentReference2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -25279,7 +25273,7 @@ static inline void convert_VkAttachmentReference2_win32_to_host(struct conversio } }

-static inline const VkAttachmentReference2 *convert_VkAttachmentReference2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, uint32_t count) +static const VkAttachmentReference2 *convert_VkAttachmentReference2_array_win32_to_host(struct conversion_context *ctx, const VkAttachmentReference232 *in, uint32_t count) { VkAttachmentReference2 *out; unsigned int i; @@ -25295,7 +25289,7 @@ static inline const VkAttachmentReference2 *convert_VkAttachmentReference2_array return out; }

-static inline void convert_VkSubpassDescription2_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, VkSubpassDescription2 *out) +static void convert_VkSubpassDescription2_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, VkSubpassDescription2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -25386,7 +25380,7 @@ static inline void convert_VkSubpassDescription2_win32_to_host(struct conversion } }

-static inline const VkSubpassDescription2 *convert_VkSubpassDescription2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, uint32_t count) +static const VkSubpassDescription2 *convert_VkSubpassDescription2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDescription232 *in, uint32_t count) { VkSubpassDescription2 *out; unsigned int i; @@ -25402,7 +25396,7 @@ static inline const VkSubpassDescription2 *convert_VkSubpassDescription2_array_w return out; }

-static inline void convert_VkSubpassDependency2_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, VkSubpassDependency2 *out) +static void convert_VkSubpassDependency2_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, VkSubpassDependency2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -25457,7 +25451,7 @@ static inline void convert_VkSubpassDependency2_win32_to_host(struct conversion_ } }

-static inline const VkSubpassDependency2 *convert_VkSubpassDependency2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, uint32_t count) +static const VkSubpassDependency2 *convert_VkSubpassDependency2_array_win32_to_host(struct conversion_context *ctx, const VkSubpassDependency232 *in, uint32_t count) { VkSubpassDependency2 *out; unsigned int i; @@ -25473,7 +25467,7 @@ static inline const VkSubpassDependency2 *convert_VkSubpassDependency2_array_win return out; }

-static inline void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo232 *in, VkRenderPassCreateInfo2 *out) +static void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_context *ctx, const VkRenderPassCreateInfo232 *in, VkRenderPassCreateInfo2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -25559,7 +25553,7 @@ static inline void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversi } }

-static inline void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerCreateInfo32 *in, VkSamplerCreateInfo *out) +static void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerCreateInfo32 *in, VkSamplerCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -25676,7 +25670,7 @@ static inline void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_c } }

-static inline void convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerYcbcrConversionCreateInfo32 *in, VkSamplerYcbcrConversionCreateInfo *out) +static void convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSamplerYcbcrConversionCreateInfo32 *in, VkSamplerYcbcrConversionCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -25717,7 +25711,7 @@ static inline void convert_VkSamplerYcbcrConversionCreateInfo_win32_to_host(stru } }

-static inline void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSemaphoreCreateInfo32 *in, VkSemaphoreCreateInfo *out) +static void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion_context *ctx, const VkSemaphoreCreateInfo32 *in, VkSemaphoreCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -25773,7 +25767,7 @@ static inline void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion } }

-static inline void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_context *ctx, const VkShaderModuleCreateInfo32 *in, VkShaderModuleCreateInfo *out) +static void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_context *ctx, const VkShaderModuleCreateInfo32 *in, VkShaderModuleCreateInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -25822,7 +25816,7 @@ static inline void convert_VkShaderModuleCreateInfo_win32_to_host(struct convers } }

-static inline void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, VkShaderCreateInfoEXT *out) +static void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, VkShaderCreateInfoEXT *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -25880,7 +25874,7 @@ static inline void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion } }

-static inline const VkShaderCreateInfoEXT *convert_VkShaderCreateInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, uint32_t count) +static const VkShaderCreateInfoEXT *convert_VkShaderCreateInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkShaderCreateInfoEXT32 *in, uint32_t count) { VkShaderCreateInfoEXT *out; unsigned int i; @@ -25896,7 +25890,7 @@ static inline const VkShaderCreateInfoEXT *convert_VkShaderCreateInfoEXT_array_w return out; }

-static inline void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkSwapchainCreateInfoKHR32 *in, VkSwapchainCreateInfoKHR *out) +static void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkSwapchainCreateInfoKHR32 *in, VkSwapchainCreateInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -26016,7 +26010,7 @@ static inline void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(stru } }

-static inline void convert_VkTensorDescriptionARM_win32_to_host(const VkTensorDescriptionARM32 *in, VkTensorDescriptionARM *out) +static void convert_VkTensorDescriptionARM_win32_to_host(const VkTensorDescriptionARM32 *in, VkTensorDescriptionARM *out) { if (!in) return;

@@ -26032,7 +26026,7 @@ static inline void convert_VkTensorDescriptionARM_win32_to_host(const VkTensorDe FIXME("Unexpected pNext\n"); }

-static inline const VkTensorDescriptionARM *convert_VkTensorDescriptionARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorDescriptionARM32 *in, uint32_t count) +static const VkTensorDescriptionARM *convert_VkTensorDescriptionARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorDescriptionARM32 *in, uint32_t count) { VkTensorDescriptionARM *out; unsigned int i; @@ -26048,7 +26042,7 @@ static inline const VkTensorDescriptionARM *convert_VkTensorDescriptionARM_array return out; }

-static inline void convert_VkTensorCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkTensorCreateInfoARM32 *in, VkTensorCreateInfoARM *out) +static void convert_VkTensorCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkTensorCreateInfoARM32 *in, VkTensorCreateInfoARM *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -26096,7 +26090,7 @@ static inline void convert_VkTensorCreateInfoARM_win32_to_host(struct conversion } }

-static inline void convert_VkTensorViewCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkTensorViewCreateInfoARM32 *in, VkTensorViewCreateInfoARM *out) +static void convert_VkTensorViewCreateInfoARM_win32_to_host(struct conversion_context *ctx, const VkTensorViewCreateInfoARM32 *in, VkTensorViewCreateInfoARM *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -26131,7 +26125,7 @@ static inline void convert_VkTensorViewCreateInfoARM_win32_to_host(struct conver } }

-static inline void convert_VkValidationCacheCreateInfoEXT_win32_to_host(const VkValidationCacheCreateInfoEXT32 *in, VkValidationCacheCreateInfoEXT *out) +static void convert_VkValidationCacheCreateInfoEXT_win32_to_host(const VkValidationCacheCreateInfoEXT32 *in, VkValidationCacheCreateInfoEXT *out) { if (!in) return;

@@ -26144,7 +26138,7 @@ static inline void convert_VkValidationCacheCreateInfoEXT_win32_to_host(const Vk FIXME("Unexpected pNext\n"); }

-static inline void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionCreateInfoKHR32 *in, VkVideoSessionCreateInfoKHR *out) +static void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionCreateInfoKHR32 *in, VkVideoSessionCreateInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -26209,7 +26203,7 @@ static inline void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conv } }

-static inline void convert_StdVideoH264SequenceParameterSetVui_win32_to_host(const StdVideoH264SequenceParameterSetVui32 *in, StdVideoH264SequenceParameterSetVui *out) +static void convert_StdVideoH264SequenceParameterSetVui_win32_to_host(const StdVideoH264SequenceParameterSetVui32 *in, StdVideoH264SequenceParameterSetVui *out) { if (!in) return;

@@ -26231,7 +26225,7 @@ static inline void convert_StdVideoH264SequenceParameterSetVui_win32_to_host(con out->pHrdParameters = UlongToPtr(in->pHrdParameters); }

-static inline const StdVideoH264SequenceParameterSetVui *convert_StdVideoH264SequenceParameterSetVui_array_win32_to_host(struct conversion_context *ctx, const StdVideoH264SequenceParameterSetVui32 *in, uint32_t count) +static const StdVideoH264SequenceParameterSetVui *convert_StdVideoH264SequenceParameterSetVui_array_win32_to_host(struct conversion_context *ctx, const StdVideoH264SequenceParameterSetVui32 *in, uint32_t count) { StdVideoH264SequenceParameterSetVui *out; unsigned int i; @@ -26247,7 +26241,7 @@ static inline const StdVideoH264SequenceParameterSetVui *convert_StdVideoH264Seq return out; }

-static inline void convert_StdVideoH264SequenceParameterSet_win32_to_host(struct conversion_context *ctx, const StdVideoH264SequenceParameterSet32 *in, StdVideoH264SequenceParameterSet *out) +static void convert_StdVideoH264SequenceParameterSet_win32_to_host(struct conversion_context *ctx, const StdVideoH264SequenceParameterSet32 *in, StdVideoH264SequenceParameterSet *out) { if (!in) return;

@@ -26278,7 +26272,7 @@ static inline void convert_StdVideoH264SequenceParameterSet_win32_to_host(struct out->pSequenceParameterSetVui = convert_StdVideoH264SequenceParameterSetVui_array_win32_to_host(ctx, (const StdVideoH264SequenceParameterSetVui32 *)UlongToPtr(in->pSequenceParameterSetVui), 1); }

-static inline const StdVideoH264SequenceParameterSet *convert_StdVideoH264SequenceParameterSet_array_win32_to_host(struct conversion_context *ctx, const StdVideoH264SequenceParameterSet32 *in, uint32_t count) +static const StdVideoH264SequenceParameterSet *convert_StdVideoH264SequenceParameterSet_array_win32_to_host(struct conversion_context *ctx, const StdVideoH264SequenceParameterSet32 *in, uint32_t count) { StdVideoH264SequenceParameterSet *out; unsigned int i; @@ -26294,7 +26288,7 @@ static inline const StdVideoH264SequenceParameterSet *convert_StdVideoH264Sequen return out; }

-static inline void convert_StdVideoH264PictureParameterSet_win32_to_host(const StdVideoH264PictureParameterSet32 *in, StdVideoH264PictureParameterSet *out) +static void convert_StdVideoH264PictureParameterSet_win32_to_host(const StdVideoH264PictureParameterSet32 *in, StdVideoH264PictureParameterSet *out) { if (!in) return;

@@ -26311,7 +26305,7 @@ static inline void convert_StdVideoH264PictureParameterSet_win32_to_host(const S out->pScalingLists = UlongToPtr(in->pScalingLists); }

-static inline const StdVideoH264PictureParameterSet *convert_StdVideoH264PictureParameterSet_array_win32_to_host(struct conversion_context *ctx, const StdVideoH264PictureParameterSet32 *in, uint32_t count) +static const StdVideoH264PictureParameterSet *convert_StdVideoH264PictureParameterSet_array_win32_to_host(struct conversion_context *ctx, const StdVideoH264PictureParameterSet32 *in, uint32_t count) { StdVideoH264PictureParameterSet *out; unsigned int i; @@ -26327,7 +26321,7 @@ static inline const StdVideoH264PictureParameterSet *convert_StdVideoH264Picture return out; }

-static inline void convert_VkVideoDecodeH264SessionParametersAddInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeH264SessionParametersAddInfoKHR32 *in, VkVideoDecodeH264SessionParametersAddInfoKHR *out) +static void convert_VkVideoDecodeH264SessionParametersAddInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeH264SessionParametersAddInfoKHR32 *in, VkVideoDecodeH264SessionParametersAddInfoKHR *out) { if (!in) return;

@@ -26341,7 +26335,7 @@ static inline void convert_VkVideoDecodeH264SessionParametersAddInfoKHR_win32_to FIXME("Unexpected pNext\n"); }

-static inline const VkVideoDecodeH264SessionParametersAddInfoKHR *convert_VkVideoDecodeH264SessionParametersAddInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeH264SessionParametersAddInfoKHR32 *in, uint32_t count) +static const VkVideoDecodeH264SessionParametersAddInfoKHR *convert_VkVideoDecodeH264SessionParametersAddInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeH264SessionParametersAddInfoKHR32 *in, uint32_t count) { VkVideoDecodeH264SessionParametersAddInfoKHR *out; unsigned int i; @@ -26357,7 +26351,7 @@ static inline const VkVideoDecodeH264SessionParametersAddInfoKHR *convert_VkVide return out; }

-static inline void convert_StdVideoAV1SequenceHeader_win32_to_host(const StdVideoAV1SequenceHeader32 *in, StdVideoAV1SequenceHeader *out) +static void convert_StdVideoAV1SequenceHeader_win32_to_host(const StdVideoAV1SequenceHeader32 *in, StdVideoAV1SequenceHeader *out) { if (!in) return;

@@ -26377,7 +26371,7 @@ static inline void convert_StdVideoAV1SequenceHeader_win32_to_host(const StdVide out->pTimingInfo = UlongToPtr(in->pTimingInfo); }

-static inline const StdVideoAV1SequenceHeader *convert_StdVideoAV1SequenceHeader_array_win32_to_host(struct conversion_context *ctx, const StdVideoAV1SequenceHeader32 *in, uint32_t count) +static const StdVideoAV1SequenceHeader *convert_StdVideoAV1SequenceHeader_array_win32_to_host(struct conversion_context *ctx, const StdVideoAV1SequenceHeader32 *in, uint32_t count) { StdVideoAV1SequenceHeader *out; unsigned int i; @@ -26393,7 +26387,7 @@ static inline const StdVideoAV1SequenceHeader *convert_StdVideoAV1SequenceHeader return out; }

-static inline void convert_VkVideoEncodeH264SessionParametersAddInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264SessionParametersAddInfoKHR32 *in, VkVideoEncodeH264SessionParametersAddInfoKHR *out) +static void convert_VkVideoEncodeH264SessionParametersAddInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264SessionParametersAddInfoKHR32 *in, VkVideoEncodeH264SessionParametersAddInfoKHR *out) { if (!in) return;

@@ -26407,7 +26401,7 @@ static inline void convert_VkVideoEncodeH264SessionParametersAddInfoKHR_win32_to FIXME("Unexpected pNext\n"); }

-static inline const VkVideoEncodeH264SessionParametersAddInfoKHR *convert_VkVideoEncodeH264SessionParametersAddInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264SessionParametersAddInfoKHR32 *in, uint32_t count) +static const VkVideoEncodeH264SessionParametersAddInfoKHR *convert_VkVideoEncodeH264SessionParametersAddInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264SessionParametersAddInfoKHR32 *in, uint32_t count) { VkVideoEncodeH264SessionParametersAddInfoKHR *out; unsigned int i; @@ -26423,7 +26417,7 @@ static inline const VkVideoEncodeH264SessionParametersAddInfoKHR *convert_VkVide return out; }

-static inline void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionParametersCreateInfoKHR32 *in, VkVideoSessionParametersCreateInfoKHR *out) +static void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionParametersCreateInfoKHR32 *in, VkVideoSessionParametersCreateInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -26520,7 +26514,7 @@ static inline void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(s } }

-static inline void convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(const VkWin32SurfaceCreateInfoKHR32 *in, VkWin32SurfaceCreateInfoKHR *out) +static void convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(const VkWin32SurfaceCreateInfoKHR32 *in, VkWin32SurfaceCreateInfoKHR *out) { if (!in) return;

@@ -26534,7 +26528,7 @@ static inline void convert_VkWin32SurfaceCreateInfoKHR_win32_to_host(const VkWin }

#ifdef _WIN64 -static inline void convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(const VkDebugMarkerObjectNameInfoEXT *in, VkDebugMarkerObjectNameInfoEXT *out) +static void convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(const VkDebugMarkerObjectNameInfoEXT *in, VkDebugMarkerObjectNameInfoEXT *out) { if (!in) return;

@@ -26546,7 +26540,7 @@ static inline void convert_VkDebugMarkerObjectNameInfoEXT_win64_to_host(const Vk } #endif /* _WIN64 */

-static inline void convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(const VkDebugMarkerObjectNameInfoEXT32 *in, VkDebugMarkerObjectNameInfoEXT *out) +static void convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(const VkDebugMarkerObjectNameInfoEXT32 *in, VkDebugMarkerObjectNameInfoEXT *out) { if (!in) return;

@@ -26560,7 +26554,7 @@ static inline void convert_VkDebugMarkerObjectNameInfoEXT_win32_to_host(const Vk }

#ifdef _WIN64 -static inline void convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(const VkDebugMarkerObjectTagInfoEXT *in, VkDebugMarkerObjectTagInfoEXT *out) +static void convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(const VkDebugMarkerObjectTagInfoEXT *in, VkDebugMarkerObjectTagInfoEXT *out) { if (!in) return;

@@ -26574,7 +26568,7 @@ static inline void convert_VkDebugMarkerObjectTagInfoEXT_win64_to_host(const VkD } #endif /* _WIN64 */

-static inline void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkDebugMarkerObjectTagInfoEXT32 *in, VkDebugMarkerObjectTagInfoEXT *out) +static void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkDebugMarkerObjectTagInfoEXT32 *in, VkDebugMarkerObjectTagInfoEXT *out) { if (!in) return;

@@ -26589,19 +26583,7 @@ static inline void convert_VkDebugMarkerObjectTagInfoEXT_win32_to_host(const VkD FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPhysicalDevice_array_unwrapped_host_to_win32(const VkPhysicalDevice *in, PTR32 *out, uint32_t count) -{ - unsigned int i; - - if (!in) return; - - for (i = 0; i < count; i++) - { - out[i] = PtrToUlong(in[i]); - } -} - -static inline void convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(const VkPhysicalDeviceGroupProperties32 *in, VkPhysicalDeviceGroupProperties *out) +static void convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_host(const VkPhysicalDeviceGroupProperties32 *in, VkPhysicalDeviceGroupProperties *out) { if (!in) return;

@@ -26611,16 +26593,7 @@ static inline void convert_VkPhysicalDeviceGroupProperties_win32_to_unwrapped_ho FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out) -{ - if (!in) return; - - out->physicalDeviceCount = in->physicalDeviceCount; - convert_VkPhysicalDevice_array_unwrapped_host_to_win32(in->physicalDevices, out->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE); - out->subsetAllocation = in->subsetAllocation; -} - -static inline VkPhysicalDeviceGroupProperties *convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceGroupProperties32 *in, uint32_t count) +static VkPhysicalDeviceGroupProperties *convert_VkPhysicalDeviceGroupProperties_array_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceGroupProperties32 *in, uint32_t count) { VkPhysicalDeviceGroupProperties *out; unsigned int i; @@ -26636,7 +26609,7 @@ static inline VkPhysicalDeviceGroupProperties *convert_VkPhysicalDeviceGroupProp return out; }

-static inline void convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out, uint32_t count) +static void convert_VkPhysicalDevice_array_unwrapped_host_to_win32(const VkPhysicalDevice *in, PTR32 *out, uint32_t count) { unsigned int i;

@@ -26644,31 +26617,42 @@ static inline void convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_

for (i = 0; i < count; i++) { - convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(&in[i], &out[i]); + out[i] = PtrToUlong(in[i]); } }

-static inline void convert_VkPerformanceCounterKHR_win32_to_host(const VkPerformanceCounterKHR32 *in, VkPerformanceCounterKHR *out) +static void convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out) { if (!in) return;

- out->sType = in->sType; - out->pNext = NULL; - if (in->pNext) - FIXME("Unexpected pNext\n"); + out->physicalDeviceCount = in->physicalDeviceCount; + convert_VkPhysicalDevice_array_unwrapped_host_to_win32(in->physicalDevices, out->physicalDevices, VK_MAX_DEVICE_GROUP_SIZE); + out->subsetAllocation = in->subsetAllocation; }

-static inline void convert_VkPerformanceCounterKHR_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out) +static void convert_VkPhysicalDeviceGroupProperties_array_unwrapped_host_to_win32(const VkPhysicalDeviceGroupProperties *in, VkPhysicalDeviceGroupProperties32 *out, uint32_t count) { + unsigned int i; + if (!in) return;

- out->unit = in->unit; - out->scope = in->scope; - out->storage = in->storage; - memcpy(out->uuid, in->uuid, VK_UUID_SIZE * sizeof(uint8_t)); + for (i = 0; i < count; i++) + { + convert_VkPhysicalDeviceGroupProperties_unwrapped_host_to_win32(&in[i], &out[i]); + } +} + +static void convert_VkPerformanceCounterKHR_win32_to_host(const VkPerformanceCounterKHR32 *in, VkPerformanceCounterKHR *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + if (in->pNext) + FIXME("Unexpected pNext\n"); }

-static inline VkPerformanceCounterKHR *convert_VkPerformanceCounterKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterKHR32 *in, uint32_t count) +static VkPerformanceCounterKHR *convert_VkPerformanceCounterKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterKHR32 *in, uint32_t count) { VkPerformanceCounterKHR *out; unsigned int i; @@ -26684,19 +26668,7 @@ static inline VkPerformanceCounterKHR *convert_VkPerformanceCounterKHR_array_win return out; }

-static inline void convert_VkPerformanceCounterKHR_array_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out, uint32_t count) -{ - unsigned int i; - - if (!in) return; - - for (i = 0; i < count; i++) - { - convert_VkPerformanceCounterKHR_host_to_win32(&in[i], &out[i]); - } -} - -static inline void convert_VkPerformanceCounterDescriptionKHR_win32_to_host(const VkPerformanceCounterDescriptionKHR32 *in, VkPerformanceCounterDescriptionKHR *out) +static void convert_VkPerformanceCounterDescriptionKHR_win32_to_host(const VkPerformanceCounterDescriptionKHR32 *in, VkPerformanceCounterDescriptionKHR *out) { if (!in) return;

@@ -26706,17 +26678,7 @@ static inline void convert_VkPerformanceCounterDescriptionKHR_win32_to_host(cons FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPerformanceCounterDescriptionKHR_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out) -{ - if (!in) return; - - out->flags = in->flags; - memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); - memcpy(out->category, in->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); - memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); -} - -static inline VkPerformanceCounterDescriptionKHR *convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterDescriptionKHR32 *in, uint32_t count) +static VkPerformanceCounterDescriptionKHR *convert_VkPerformanceCounterDescriptionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPerformanceCounterDescriptionKHR32 *in, uint32_t count) { VkPerformanceCounterDescriptionKHR *out; unsigned int i; @@ -26732,7 +26694,17 @@ static inline VkPerformanceCounterDescriptionKHR *convert_VkPerformanceCounterDe return out; }

-static inline void convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out, uint32_t count) +static void convert_VkPerformanceCounterKHR_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out) +{ + if (!in) return; + + out->unit = in->unit; + out->scope = in->scope; + out->storage = in->storage; + memcpy(out->uuid, in->uuid, VK_UUID_SIZE * sizeof(uint8_t)); +} + +static void convert_VkPerformanceCounterKHR_array_host_to_win32(const VkPerformanceCounterKHR *in, VkPerformanceCounterKHR32 *out, uint32_t count) { unsigned int i;

@@ -26740,38 +26712,47 @@ static inline void convert_VkPerformanceCounterDescriptionKHR_array_host_to_win3

for (i = 0; i < count; i++) { - convert_VkPerformanceCounterDescriptionKHR_host_to_win32(&in[i], &out[i]); + convert_VkPerformanceCounterKHR_host_to_win32(&in[i], &out[i]); } }

-#ifdef _WIN64 -static inline void convert_VkMappedMemoryRange_win64_to_host(const VkMappedMemoryRange *in, VkMappedMemoryRange *out) +static void convert_VkPerformanceCounterDescriptionKHR_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out) { if (!in) return;

- out->sType = in->sType; - out->pNext = in->pNext; - out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory; - out->offset = in->offset; - out->size = in->size; + out->flags = in->flags; + memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); + memcpy(out->category, in->category, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); + memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); +} + +static void convert_VkPerformanceCounterDescriptionKHR_array_host_to_win32(const VkPerformanceCounterDescriptionKHR *in, VkPerformanceCounterDescriptionKHR32 *out, uint32_t count) +{ + unsigned int i; + + if (!in) return; + + for (i = 0; i < count; i++) + { + convert_VkPerformanceCounterDescriptionKHR_host_to_win32(&in[i], &out[i]); + } } -#endif /* _WIN64 */

-static inline void convert_VkMappedMemoryRange_win32_to_host(const VkMappedMemoryRange32 *in, VkMappedMemoryRange *out) +#ifdef _WIN64 +static void convert_VkMappedMemoryRange_win64_to_host(const VkMappedMemoryRange *in, VkMappedMemoryRange *out) { if (!in) return;

out->sType = in->sType; - out->pNext = NULL; + out->pNext = in->pNext; out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory; out->offset = in->offset; out->size = in->size; - if (in->pNext) - FIXME("Unexpected pNext\n"); } +#endif /* _WIN64 */

#ifdef _WIN64 -static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win64_to_host(struct conversion_context *ctx, const VkMappedMemoryRange *in, uint32_t count) +static const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win64_to_host(struct conversion_context *ctx, const VkMappedMemoryRange *in, uint32_t count) { VkMappedMemoryRange *out; unsigned int i; @@ -26788,7 +26769,20 @@ static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win64 } #endif /* _WIN64 */

-static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win32_to_host(struct conversion_context *ctx, const VkMappedMemoryRange32 *in, uint32_t count) +static void convert_VkMappedMemoryRange_win32_to_host(const VkMappedMemoryRange32 *in, VkMappedMemoryRange *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->memory = vulkan_device_memory_from_handle(in->memory)->host.device_memory; + out->offset = in->offset; + out->size = in->size; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win32_to_host(struct conversion_context *ctx, const VkMappedMemoryRange32 *in, uint32_t count) { VkMappedMemoryRange *out; unsigned int i; @@ -26804,7 +26798,7 @@ static inline const VkMappedMemoryRange *convert_VkMappedMemoryRange_array_win32 return out; }

-static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(const VkAccelerationStructureBuildSizesInfoKHR32 *in, VkAccelerationStructureBuildSizesInfoKHR *out) +static void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_host(const VkAccelerationStructureBuildSizesInfoKHR32 *in, VkAccelerationStructureBuildSizesInfoKHR *out) { if (!in) return;

@@ -26814,7 +26808,7 @@ static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_win32_to_hos FIXME("Unexpected pNext\n"); }

-static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(const VkAccelerationStructureBuildSizesInfoKHR *in, VkAccelerationStructureBuildSizesInfoKHR32 *out) +static void convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win32(const VkAccelerationStructureBuildSizesInfoKHR *in, VkAccelerationStructureBuildSizesInfoKHR32 *out) { if (!in) return;

@@ -26823,7 +26817,7 @@ static inline void convert_VkAccelerationStructureBuildSizesInfoKHR_host_to_win3 out->buildScratchSize = in->buildScratchSize; }

-static inline void convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host(const VkAccelerationStructureDeviceAddressInfoKHR32 *in, VkAccelerationStructureDeviceAddressInfoKHR *out) +static void convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_host(const VkAccelerationStructureDeviceAddressInfoKHR32 *in, VkAccelerationStructureDeviceAddressInfoKHR *out) { if (!in) return;

@@ -26834,7 +26828,7 @@ static inline void convert_VkAccelerationStructureDeviceAddressInfoKHR_win32_to_ FIXME("Unexpected pNext\n"); }

-static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host(const VkAccelerationStructureMemoryRequirementsInfoNV32 *in, VkAccelerationStructureMemoryRequirementsInfoNV *out) +static void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32_to_host(const VkAccelerationStructureMemoryRequirementsInfoNV32 *in, VkAccelerationStructureMemoryRequirementsInfoNV *out) { if (!in) return;

@@ -26846,33 +26840,33 @@ static inline void convert_VkAccelerationStructureMemoryRequirementsInfoNV_win32 FIXME("Unexpected pNext\n"); }

-static inline void convert_VkMemoryRequirements_host_to_win32(const VkMemoryRequirements *in, VkMemoryRequirements32 *out) +static void convert_VkMemoryRequirements2KHR_win32_to_host(const VkMemoryRequirements2KHR32 *in, VkMemoryRequirements2KHR *out) { if (!in) return;

- out->size = in->size; - out->alignment = in->alignment; - out->memoryTypeBits = in->memoryTypeBits; + out->sType = in->sType; + out->pNext = NULL; + if (in->pNext) + FIXME("Unexpected pNext\n"); }

-static inline void convert_VkMemoryRequirements2KHR_win32_to_host(const VkMemoryRequirements2KHR32 *in, VkMemoryRequirements2KHR *out) +static void convert_VkMemoryRequirements_host_to_win32(const VkMemoryRequirements *in, VkMemoryRequirements32 *out) { if (!in) return;

- out->sType = in->sType; - out->pNext = NULL; - if (in->pNext) - FIXME("Unexpected pNext\n"); + out->size = in->size; + out->alignment = in->alignment; + out->memoryTypeBits = in->memoryTypeBits; }

-static inline void convert_VkMemoryRequirements2KHR_host_to_win32(const VkMemoryRequirements2KHR *in, VkMemoryRequirements2KHR32 *out) +static void convert_VkMemoryRequirements2KHR_host_to_win32(const VkMemoryRequirements2KHR *in, VkMemoryRequirements2KHR32 *out) { if (!in) return;

convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements); }

-static inline void convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host(const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *in, VkAccelerationStructureCaptureDescriptorDataInfoEXT *out) +static void convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_win32_to_host(const VkAccelerationStructureCaptureDescriptorDataInfoEXT32 *in, VkAccelerationStructureCaptureDescriptorDataInfoEXT *out) { if (!in) return;

@@ -26884,7 +26878,7 @@ static inline void convert_VkAccelerationStructureCaptureDescriptorDataInfoEXT_w FIXME("Unexpected pNext\n"); }

-static inline void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBufferDeviceAddressInfo32 *in, VkBufferDeviceAddressInfo *out) +static void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBufferDeviceAddressInfo32 *in, VkBufferDeviceAddressInfo *out) { if (!in) return;

@@ -26895,7 +26889,7 @@ static inline void convert_VkBufferDeviceAddressInfo_win32_to_host(const VkBuffe FIXME("Unexpected pNext\n"); }

-static inline void convert_VkBufferMemoryRequirementsInfo2_win32_to_host(const VkBufferMemoryRequirementsInfo232 *in, VkBufferMemoryRequirementsInfo2 *out) +static void convert_VkBufferMemoryRequirementsInfo2_win32_to_host(const VkBufferMemoryRequirementsInfo232 *in, VkBufferMemoryRequirementsInfo2 *out) { if (!in) return;

@@ -26906,7 +26900,7 @@ static inline void convert_VkBufferMemoryRequirementsInfo2_win32_to_host(const V FIXME("Unexpected pNext\n"); }

-static inline void convert_VkMemoryRequirements2_win32_to_host(struct conversion_context *ctx, const VkMemoryRequirements232 *in, VkMemoryRequirements2 *out) +static void convert_VkMemoryRequirements2_win32_to_host(struct conversion_context *ctx, const VkMemoryRequirements232 *in, VkMemoryRequirements2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -26948,7 +26942,7 @@ static inline void convert_VkMemoryRequirements2_win32_to_host(struct conversion } }

-static inline void convert_VkMemoryRequirements2_host_to_win32(const VkMemoryRequirements2 *in, VkMemoryRequirements232 *out) +static void convert_VkMemoryRequirements2_host_to_win32(const VkMemoryRequirements2 *in, VkMemoryRequirements232 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -26987,7 +26981,7 @@ static inline void convert_VkMemoryRequirements2_host_to_win32(const VkMemoryReq } }

-static inline void convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host(const VkBufferCaptureDescriptorDataInfoEXT32 *in, VkBufferCaptureDescriptorDataInfoEXT *out) +static void convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host(const VkBufferCaptureDescriptorDataInfoEXT32 *in, VkBufferCaptureDescriptorDataInfoEXT *out) { if (!in) return;

@@ -26998,7 +26992,7 @@ static inline void convert_VkBufferCaptureDescriptorDataInfoEXT_win32_to_host(co FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCalibratedTimestampInfoKHR_win32_to_host(const VkCalibratedTimestampInfoKHR32 *in, VkCalibratedTimestampInfoKHR *out) +static void convert_VkCalibratedTimestampInfoKHR_win32_to_host(const VkCalibratedTimestampInfoKHR32 *in, VkCalibratedTimestampInfoKHR *out) { if (!in) return;

@@ -27009,7 +27003,7 @@ static inline void convert_VkCalibratedTimestampInfoKHR_win32_to_host(const VkCa FIXME("Unexpected pNext\n"); }

-static inline const VkCalibratedTimestampInfoKHR *convert_VkCalibratedTimestampInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoKHR32 *in, uint32_t count) +static const VkCalibratedTimestampInfoKHR *convert_VkCalibratedTimestampInfoKHR_array_win32_to_host(struct conversion_context *ctx, const VkCalibratedTimestampInfoKHR32 *in, uint32_t count) { VkCalibratedTimestampInfoKHR *out; unsigned int i; @@ -27025,7 +27019,7 @@ static inline const VkCalibratedTimestampInfoKHR *convert_VkCalibratedTimestampI return out; }

-static inline void convert_VkDataGraphPipelineInfoARM_win32_to_host(const VkDataGraphPipelineInfoARM32 *in, VkDataGraphPipelineInfoARM *out) +static void convert_VkDataGraphPipelineInfoARM_win32_to_host(const VkDataGraphPipelineInfoARM32 *in, VkDataGraphPipelineInfoARM *out) { if (!in) return;

@@ -27036,7 +27030,7 @@ static inline void convert_VkDataGraphPipelineInfoARM_win32_to_host(const VkData FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDataGraphPipelinePropertyQueryResultARM_win32_to_host(const VkDataGraphPipelinePropertyQueryResultARM32 *in, VkDataGraphPipelinePropertyQueryResultARM *out) +static void convert_VkDataGraphPipelinePropertyQueryResultARM_win32_to_host(const VkDataGraphPipelinePropertyQueryResultARM32 *in, VkDataGraphPipelinePropertyQueryResultARM *out) { if (!in) return;

@@ -27050,17 +27044,7 @@ static inline void convert_VkDataGraphPipelinePropertyQueryResultARM_win32_to_ho FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDataGraphPipelinePropertyQueryResultARM_host_to_win32(const VkDataGraphPipelinePropertyQueryResultARM *in, VkDataGraphPipelinePropertyQueryResultARM32 *out) -{ - if (!in) return; - - out->property = in->property; - out->isText = in->isText; - out->dataSize = in->dataSize; - out->pData = PtrToUlong(in->pData); -} - -static inline VkDataGraphPipelinePropertyQueryResultARM *convert_VkDataGraphPipelinePropertyQueryResultARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelinePropertyQueryResultARM32 *in, uint32_t count) +static VkDataGraphPipelinePropertyQueryResultARM *convert_VkDataGraphPipelinePropertyQueryResultARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelinePropertyQueryResultARM32 *in, uint32_t count) { VkDataGraphPipelinePropertyQueryResultARM *out; unsigned int i; @@ -27076,7 +27060,17 @@ static inline VkDataGraphPipelinePropertyQueryResultARM *convert_VkDataGraphPipe return out; }

-static inline void convert_VkDataGraphPipelinePropertyQueryResultARM_array_host_to_win32(const VkDataGraphPipelinePropertyQueryResultARM *in, VkDataGraphPipelinePropertyQueryResultARM32 *out, uint32_t count) +static void convert_VkDataGraphPipelinePropertyQueryResultARM_host_to_win32(const VkDataGraphPipelinePropertyQueryResultARM *in, VkDataGraphPipelinePropertyQueryResultARM32 *out) +{ + if (!in) return; + + out->property = in->property; + out->isText = in->isText; + out->dataSize = in->dataSize; + out->pData = PtrToUlong(in->pData); +} + +static void convert_VkDataGraphPipelinePropertyQueryResultARM_array_host_to_win32(const VkDataGraphPipelinePropertyQueryResultARM *in, VkDataGraphPipelinePropertyQueryResultARM32 *out, uint32_t count) { unsigned int i;

@@ -27088,7 +27082,7 @@ static inline void convert_VkDataGraphPipelinePropertyQueryResultARM_array_host_ } }

-static inline void convert_VkDataGraphPipelineSessionBindPointRequirementsInfoARM_win32_to_host(const VkDataGraphPipelineSessionBindPointRequirementsInfoARM32 *in, VkDataGraphPipelineSessionBindPointRequirementsInfoARM *out) +static void convert_VkDataGraphPipelineSessionBindPointRequirementsInfoARM_win32_to_host(const VkDataGraphPipelineSessionBindPointRequirementsInfoARM32 *in, VkDataGraphPipelineSessionBindPointRequirementsInfoARM *out) { if (!in) return;

@@ -27099,7 +27093,7 @@ static inline void convert_VkDataGraphPipelineSessionBindPointRequirementsInfoAR FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDataGraphPipelineSessionBindPointRequirementARM_win32_to_host(const VkDataGraphPipelineSessionBindPointRequirementARM32 *in, VkDataGraphPipelineSessionBindPointRequirementARM *out) +static void convert_VkDataGraphPipelineSessionBindPointRequirementARM_win32_to_host(const VkDataGraphPipelineSessionBindPointRequirementARM32 *in, VkDataGraphPipelineSessionBindPointRequirementARM *out) { if (!in) return;

@@ -27112,16 +27106,7 @@ static inline void convert_VkDataGraphPipelineSessionBindPointRequirementARM_win FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDataGraphPipelineSessionBindPointRequirementARM_host_to_win32(const VkDataGraphPipelineSessionBindPointRequirementARM *in, VkDataGraphPipelineSessionBindPointRequirementARM32 *out) -{ - if (!in) return; - - out->bindPoint = in->bindPoint; - out->bindPointType = in->bindPointType; - out->numObjects = in->numObjects; -} - -static inline VkDataGraphPipelineSessionBindPointRequirementARM *convert_VkDataGraphPipelineSessionBindPointRequirementARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineSessionBindPointRequirementARM32 *in, uint32_t count) +static VkDataGraphPipelineSessionBindPointRequirementARM *convert_VkDataGraphPipelineSessionBindPointRequirementARM_array_win32_to_host(struct conversion_context *ctx, const VkDataGraphPipelineSessionBindPointRequirementARM32 *in, uint32_t count) { VkDataGraphPipelineSessionBindPointRequirementARM *out; unsigned int i; @@ -27137,7 +27122,16 @@ static inline VkDataGraphPipelineSessionBindPointRequirementARM *convert_VkDataG return out; }

-static inline void convert_VkDataGraphPipelineSessionBindPointRequirementARM_array_host_to_win32(const VkDataGraphPipelineSessionBindPointRequirementARM *in, VkDataGraphPipelineSessionBindPointRequirementARM32 *out, uint32_t count) +static void convert_VkDataGraphPipelineSessionBindPointRequirementARM_host_to_win32(const VkDataGraphPipelineSessionBindPointRequirementARM *in, VkDataGraphPipelineSessionBindPointRequirementARM32 *out) +{ + if (!in) return; + + out->bindPoint = in->bindPoint; + out->bindPointType = in->bindPointType; + out->numObjects = in->numObjects; +} + +static void convert_VkDataGraphPipelineSessionBindPointRequirementARM_array_host_to_win32(const VkDataGraphPipelineSessionBindPointRequirementARM *in, VkDataGraphPipelineSessionBindPointRequirementARM32 *out, uint32_t count) { unsigned int i;

@@ -27149,7 +27143,7 @@ static inline void convert_VkDataGraphPipelineSessionBindPointRequirementARM_arr } }

-static inline void convert_VkDataGraphPipelineSessionMemoryRequirementsInfoARM_win32_to_host(const VkDataGraphPipelineSessionMemoryRequirementsInfoARM32 *in, VkDataGraphPipelineSessionMemoryRequirementsInfoARM *out) +static void convert_VkDataGraphPipelineSessionMemoryRequirementsInfoARM_win32_to_host(const VkDataGraphPipelineSessionMemoryRequirementsInfoARM32 *in, VkDataGraphPipelineSessionMemoryRequirementsInfoARM *out) { if (!in) return;

@@ -27162,7 +27156,7 @@ static inline void convert_VkDataGraphPipelineSessionMemoryRequirementsInfoARM_w FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDescriptorAddressInfoEXT_win32_to_host(const VkDescriptorAddressInfoEXT32 *in, VkDescriptorAddressInfoEXT *out) +static void convert_VkDescriptorAddressInfoEXT_win32_to_host(const VkDescriptorAddressInfoEXT32 *in, VkDescriptorAddressInfoEXT *out) { if (!in) return;

@@ -27175,7 +27169,7 @@ static inline void convert_VkDescriptorAddressInfoEXT_win32_to_host(const VkDesc FIXME("Unexpected pNext\n"); }

-static inline const VkDescriptorAddressInfoEXT *convert_VkDescriptorAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorAddressInfoEXT32 *in, uint32_t count) +static const VkDescriptorAddressInfoEXT *convert_VkDescriptorAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDescriptorAddressInfoEXT32 *in, uint32_t count) { VkDescriptorAddressInfoEXT *out; unsigned int i; @@ -27191,7 +27185,7 @@ static inline const VkDescriptorAddressInfoEXT *convert_VkDescriptorAddressInfoE return out; }

-static inline void convert_VkDescriptorDataEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorDataEXT32 *in, VkDescriptorDataEXT *out, VkFlags selector) +static void convert_VkDescriptorDataEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorDataEXT32 *in, VkDescriptorDataEXT *out, VkFlags selector) { if (!in) return;

@@ -27217,7 +27211,7 @@ static inline void convert_VkDescriptorDataEXT_win32_to_host(struct conversion_c out->accelerationStructure = in->accelerationStructure; }

-static inline void convert_VkDescriptorGetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorGetInfoEXT32 *in, VkDescriptorGetInfoEXT *out) +static void convert_VkDescriptorGetInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDescriptorGetInfoEXT32 *in, VkDescriptorGetInfoEXT *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -27251,7 +27245,7 @@ static inline void convert_VkDescriptorGetInfoEXT_win32_to_host(struct conversio } }

-static inline void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(const VkDescriptorSetBindingReferenceVALVE32 *in, VkDescriptorSetBindingReferenceVALVE *out) +static void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(const VkDescriptorSetBindingReferenceVALVE32 *in, VkDescriptorSetBindingReferenceVALVE *out) { if (!in) return;

@@ -27263,7 +27257,7 @@ static inline void convert_VkDescriptorSetBindingReferenceVALVE_win32_to_host(co FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host(const VkDescriptorSetLayoutHostMappingInfoVALVE32 *in, VkDescriptorSetLayoutHostMappingInfoVALVE *out) +static void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_host(const VkDescriptorSetLayoutHostMappingInfoVALVE32 *in, VkDescriptorSetLayoutHostMappingInfoVALVE *out) { if (!in) return;

@@ -27275,7 +27269,7 @@ static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_win32_to_ho FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(const VkDescriptorSetLayoutHostMappingInfoVALVE *in, VkDescriptorSetLayoutHostMappingInfoVALVE32 *out) +static void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win32(const VkDescriptorSetLayoutHostMappingInfoVALVE *in, VkDescriptorSetLayoutHostMappingInfoVALVE32 *out) { if (!in) return;

@@ -27283,7 +27277,7 @@ static inline void convert_VkDescriptorSetLayoutHostMappingInfoVALVE_host_to_win out->descriptorSize = in->descriptorSize; }

-static inline void convert_VkDescriptorSetLayoutSupport_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutSupport32 *in, VkDescriptorSetLayoutSupport *out) +static void convert_VkDescriptorSetLayoutSupport_win32_to_host(struct conversion_context *ctx, const VkDescriptorSetLayoutSupport32 *in, VkDescriptorSetLayoutSupport *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -27313,7 +27307,7 @@ static inline void convert_VkDescriptorSetLayoutSupport_win32_to_host(struct con } }

-static inline void convert_VkDescriptorSetLayoutSupport_host_to_win32(const VkDescriptorSetLayoutSupport *in, VkDescriptorSetLayoutSupport32 *out) +static void convert_VkDescriptorSetLayoutSupport_host_to_win32(const VkDescriptorSetLayoutSupport *in, VkDescriptorSetLayoutSupport32 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -27341,7 +27335,7 @@ static inline void convert_VkDescriptorSetLayoutSupport_host_to_win32(const VkDe } }

-static inline void convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(const VkAccelerationStructureVersionInfoKHR32 *in, VkAccelerationStructureVersionInfoKHR *out) +static void convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(const VkAccelerationStructureVersionInfoKHR32 *in, VkAccelerationStructureVersionInfoKHR *out) { if (!in) return;

@@ -27352,7 +27346,7 @@ static inline void convert_VkAccelerationStructureVersionInfoKHR_win32_to_host(c FIXME("Unexpected pNext\n"); }

-static inline const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, uint32_t count) +static const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkBufferCreateInfo32 *in, uint32_t count) { VkBufferCreateInfo *out; unsigned int i; @@ -27368,7 +27362,7 @@ static inline const VkBufferCreateInfo *convert_VkBufferCreateInfo_array_win32_t return out; }

-static inline void convert_VkDeviceBufferMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceBufferMemoryRequirements32 *in, VkDeviceBufferMemoryRequirements *out) +static void convert_VkDeviceBufferMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceBufferMemoryRequirements32 *in, VkDeviceBufferMemoryRequirements *out) { if (!in) return;

@@ -27379,7 +27373,7 @@ static inline void convert_VkDeviceBufferMemoryRequirements_win32_to_host(struct FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFaultCountsEXT32 *in, VkDeviceFaultCountsEXT *out) +static void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFaultCountsEXT32 *in, VkDeviceFaultCountsEXT *out) { if (!in) return;

@@ -27392,36 +27386,43 @@ static inline void convert_VkDeviceFaultCountsEXT_win32_to_host(const VkDeviceFa FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDeviceFaultCountsEXT_host_to_win32(const VkDeviceFaultCountsEXT *in, VkDeviceFaultCountsEXT32 *out) +static void convert_VkDeviceFaultAddressInfoEXT_win32_to_host(const VkDeviceFaultAddressInfoEXT32 *in, VkDeviceFaultAddressInfoEXT *out) { if (!in) return;

- out->addressInfoCount = in->addressInfoCount; - out->vendorInfoCount = in->vendorInfoCount; - out->vendorBinarySize = in->vendorBinarySize; + out->addressType = in->addressType; + out->reportedAddress = in->reportedAddress; + out->addressPrecision = in->addressPrecision; }

-static inline void convert_VkDeviceFaultAddressInfoEXT_win32_to_host(const VkDeviceFaultAddressInfoEXT32 *in, VkDeviceFaultAddressInfoEXT *out) +static VkDeviceFaultAddressInfoEXT *convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultAddressInfoEXT32 *in, uint32_t count) { - if (!in) return; + VkDeviceFaultAddressInfoEXT *out; + unsigned int i;

- out->addressType = in->addressType; - out->reportedAddress = in->reportedAddress; - out->addressPrecision = in->addressPrecision; + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkDeviceFaultAddressInfoEXT_win32_to_host(&in[i], &out[i]); + } + + return out; }

-static inline void convert_VkDeviceFaultAddressInfoEXT_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out) +static void convert_VkDeviceFaultVendorInfoEXT_win32_to_host(const VkDeviceFaultVendorInfoEXT32 *in, VkDeviceFaultVendorInfoEXT *out) { if (!in) return;

- out->addressType = in->addressType; - out->reportedAddress = in->reportedAddress; - out->addressPrecision = in->addressPrecision; + memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); + out->vendorFaultCode = in->vendorFaultCode; + out->vendorFaultData = in->vendorFaultData; }

-static inline VkDeviceFaultAddressInfoEXT *convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultAddressInfoEXT32 *in, uint32_t count) +static VkDeviceFaultVendorInfoEXT *convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultVendorInfoEXT32 *in, uint32_t count) { - VkDeviceFaultAddressInfoEXT *out; + VkDeviceFaultVendorInfoEXT *out; unsigned int i;

if (!in || !count) return NULL; @@ -27429,13 +27430,43 @@ static inline VkDeviceFaultAddressInfoEXT *convert_VkDeviceFaultAddressInfoEXT_a out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkDeviceFaultAddressInfoEXT_win32_to_host(&in[i], &out[i]); + convert_VkDeviceFaultVendorInfoEXT_win32_to_host(&in[i], &out[i]); }

return out; }

-static inline void convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out, uint32_t count) +static void convert_VkDeviceFaultInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultInfoEXT32 *in, VkDeviceFaultInfoEXT *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(in->pAddressInfos), 1); + out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(in->pVendorInfos), 1); + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static void convert_VkDeviceFaultCountsEXT_host_to_win32(const VkDeviceFaultCountsEXT *in, VkDeviceFaultCountsEXT32 *out) +{ + if (!in) return; + + out->addressInfoCount = in->addressInfoCount; + out->vendorInfoCount = in->vendorInfoCount; + out->vendorBinarySize = in->vendorBinarySize; +} + +static void convert_VkDeviceFaultAddressInfoEXT_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out) +{ + if (!in) return; + + out->addressType = in->addressType; + out->reportedAddress = in->reportedAddress; + out->addressPrecision = in->addressPrecision; +} + +static void convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(const VkDeviceFaultAddressInfoEXT *in, VkDeviceFaultAddressInfoEXT32 *out, uint32_t count) { unsigned int i;

@@ -27447,16 +27478,7 @@ static inline void convert_VkDeviceFaultAddressInfoEXT_array_host_to_win32(const } }

-static inline void convert_VkDeviceFaultVendorInfoEXT_win32_to_host(const VkDeviceFaultVendorInfoEXT32 *in, VkDeviceFaultVendorInfoEXT *out) -{ - if (!in) return; - - memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); - out->vendorFaultCode = in->vendorFaultCode; - out->vendorFaultData = in->vendorFaultData; -} - -static inline void convert_VkDeviceFaultVendorInfoEXT_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out) +static void convert_VkDeviceFaultVendorInfoEXT_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out) { if (!in) return;

@@ -27465,23 +27487,7 @@ static inline void convert_VkDeviceFaultVendorInfoEXT_host_to_win32(const VkDevi out->vendorFaultData = in->vendorFaultData; }

-static inline VkDeviceFaultVendorInfoEXT *convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultVendorInfoEXT32 *in, uint32_t count) -{ - VkDeviceFaultVendorInfoEXT *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkDeviceFaultVendorInfoEXT_win32_to_host(&in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out, uint32_t count) +static void convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(const VkDeviceFaultVendorInfoEXT *in, VkDeviceFaultVendorInfoEXT32 *out, uint32_t count) { unsigned int i;

@@ -27493,19 +27499,7 @@ static inline void convert_VkDeviceFaultVendorInfoEXT_array_host_to_win32(const } }

-static inline void convert_VkDeviceFaultInfoEXT_win32_to_host(struct conversion_context *ctx, const VkDeviceFaultInfoEXT32 *in, VkDeviceFaultInfoEXT *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->pAddressInfos = convert_VkDeviceFaultAddressInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultAddressInfoEXT32 *)UlongToPtr(in->pAddressInfos), 1); - out->pVendorInfos = convert_VkDeviceFaultVendorInfoEXT_array_win32_to_host(ctx, (VkDeviceFaultVendorInfoEXT32 *)UlongToPtr(in->pVendorInfos), 1); - if (in->pNext) - FIXME("Unexpected pNext\n"); -} - -static inline void convert_VkDeviceFaultInfoEXT_host_to_win32(const VkDeviceFaultInfoEXT *in, VkDeviceFaultInfoEXT32 *out) +static void convert_VkDeviceFaultInfoEXT_host_to_win32(const VkDeviceFaultInfoEXT *in, VkDeviceFaultInfoEXT32 *out) { if (!in) return;

@@ -27515,7 +27509,7 @@ static inline void convert_VkDeviceFaultInfoEXT_host_to_win32(const VkDeviceFaul out->pVendorBinaryData = PtrToUlong(in->pVendorBinaryData); }

-static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(const VkDeviceGroupPresentCapabilitiesKHR32 *in, VkDeviceGroupPresentCapabilitiesKHR *out) +static void convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(const VkDeviceGroupPresentCapabilitiesKHR32 *in, VkDeviceGroupPresentCapabilitiesKHR *out) { if (!in) return;

@@ -27525,7 +27519,7 @@ static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_win32_to_host(con FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(const VkDeviceGroupPresentCapabilitiesKHR *in, VkDeviceGroupPresentCapabilitiesKHR32 *out) +static void convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(const VkDeviceGroupPresentCapabilitiesKHR *in, VkDeviceGroupPresentCapabilitiesKHR32 *out) { if (!in) return;

@@ -27534,7 +27528,7 @@ static inline void convert_VkDeviceGroupPresentCapabilitiesKHR_host_to_win32(con }

#ifdef _WIN64 -static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkImageCreateInfo *in, uint32_t count) +static const VkImageCreateInfo *convert_VkImageCreateInfo_array_win64_to_host(struct conversion_context *ctx, const VkImageCreateInfo *in, uint32_t count) { VkImageCreateInfo *out; unsigned int i; @@ -27551,7 +27545,19 @@ static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win64_to_ } #endif /* _WIN64 */

-static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, uint32_t count) +#ifdef _WIN64 +static void convert_VkDeviceImageMemoryRequirements_win64_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements *in, VkDeviceImageMemoryRequirements *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->pCreateInfo = convert_VkImageCreateInfo_array_win64_to_host(ctx, in->pCreateInfo, 1); + out->planeAspect = in->planeAspect; +} +#endif /* _WIN64 */ + +static const VkImageCreateInfo *convert_VkImageCreateInfo_array_win32_to_host(struct conversion_context *ctx, const VkImageCreateInfo32 *in, uint32_t count) { VkImageCreateInfo *out; unsigned int i; @@ -27567,19 +27573,7 @@ static inline const VkImageCreateInfo *convert_VkImageCreateInfo_array_win32_to_ return out; }

-#ifdef _WIN64 -static inline void convert_VkDeviceImageMemoryRequirements_win64_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements *in, VkDeviceImageMemoryRequirements *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = in->pNext; - out->pCreateInfo = convert_VkImageCreateInfo_array_win64_to_host(ctx, in->pCreateInfo, 1); - out->planeAspect = in->planeAspect; -} -#endif /* _WIN64 */ - -static inline void convert_VkDeviceImageMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements32 *in, VkDeviceImageMemoryRequirements *out) +static void convert_VkDeviceImageMemoryRequirements_win32_to_host(struct conversion_context *ctx, const VkDeviceImageMemoryRequirements32 *in, VkDeviceImageMemoryRequirements *out) { if (!in) return;

@@ -27591,18 +27585,7 @@ static inline void convert_VkDeviceImageMemoryRequirements_win32_to_host(struct FIXME("Unexpected pNext\n"); }

-static inline void convert_VkSparseImageMemoryRequirements_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out) -{ - if (!in) return; - - out->formatProperties = in->formatProperties; - out->imageMipTailFirstLod = in->imageMipTailFirstLod; - out->imageMipTailSize = in->imageMipTailSize; - out->imageMipTailOffset = in->imageMipTailOffset; - out->imageMipTailStride = in->imageMipTailStride; -} - -static inline void convert_VkSparseImageMemoryRequirements2_win32_to_host(const VkSparseImageMemoryRequirements232 *in, VkSparseImageMemoryRequirements2 *out) +static void convert_VkSparseImageMemoryRequirements2_win32_to_host(const VkSparseImageMemoryRequirements232 *in, VkSparseImageMemoryRequirements2 *out) { if (!in) return;

@@ -27612,14 +27595,7 @@ static inline void convert_VkSparseImageMemoryRequirements2_win32_to_host(const FIXME("Unexpected pNext\n"); }

-static inline void convert_VkSparseImageMemoryRequirements2_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out) -{ - if (!in) return; - - convert_VkSparseImageMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements); -} - -static inline VkSparseImageMemoryRequirements2 *convert_VkSparseImageMemoryRequirements2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryRequirements232 *in, uint32_t count) +static VkSparseImageMemoryRequirements2 *convert_VkSparseImageMemoryRequirements2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryRequirements232 *in, uint32_t count) { VkSparseImageMemoryRequirements2 *out; unsigned int i; @@ -27635,47 +27611,38 @@ static inline VkSparseImageMemoryRequirements2 *convert_VkSparseImageMemoryRequi return out; }

-static inline void convert_VkSparseImageMemoryRequirements2_array_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out, uint32_t count) +static void convert_VkSparseImageMemoryRequirements_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out) { - unsigned int i; - if (!in) return;

- for (i = 0; i < count; i++) - { - convert_VkSparseImageMemoryRequirements2_host_to_win32(&in[i], &out[i]); - } + out->formatProperties = in->formatProperties; + out->imageMipTailFirstLod = in->imageMipTailFirstLod; + out->imageMipTailSize = in->imageMipTailSize; + out->imageMipTailOffset = in->imageMipTailOffset; + out->imageMipTailStride = in->imageMipTailStride; }

-static inline void convert_VkImageSubresource2_win32_to_host(const VkImageSubresource232 *in, VkImageSubresource2 *out) +static void convert_VkSparseImageMemoryRequirements2_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out) { if (!in) return;

- out->sType = in->sType; - out->pNext = NULL; - out->imageSubresource = in->imageSubresource; - if (in->pNext) - FIXME("Unexpected pNext\n"); + convert_VkSparseImageMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements); }

-static inline const VkImageSubresource2 *convert_VkImageSubresource2_array_win32_to_host(struct conversion_context *ctx, const VkImageSubresource232 *in, uint32_t count) +static void convert_VkSparseImageMemoryRequirements2_array_host_to_win32(const VkSparseImageMemoryRequirements2 *in, VkSparseImageMemoryRequirements232 *out, uint32_t count) { - VkImageSubresource2 *out; unsigned int i;

- if (!in || !count) return NULL; + if (!in) return;

- out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkImageSubresource2_win32_to_host(&in[i], &out[i]); + convert_VkSparseImageMemoryRequirements2_host_to_win32(&in[i], &out[i]); } - - return out; }

#ifdef _WIN64 -static inline void convert_VkDeviceImageSubresourceInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceImageSubresourceInfo *in, VkDeviceImageSubresourceInfo *out) +static void convert_VkDeviceImageSubresourceInfo_win64_to_host(struct conversion_context *ctx, const VkDeviceImageSubresourceInfo *in, VkDeviceImageSubresourceInfo *out) { if (!in) return;

@@ -27686,41 +27653,46 @@ static inline void convert_VkDeviceImageSubresourceInfo_win64_to_host(struct con } #endif /* _WIN64 */

-static inline void convert_VkDeviceImageSubresourceInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceImageSubresourceInfo32 *in, VkDeviceImageSubresourceInfo *out) +static void convert_VkImageSubresource2_win32_to_host(const VkImageSubresource232 *in, VkImageSubresource2 *out) { if (!in) return;

out->sType = in->sType; out->pNext = NULL; - out->pCreateInfo = convert_VkImageCreateInfo_array_win32_to_host(ctx, (const VkImageCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1); - out->pSubresource = convert_VkImageSubresource2_array_win32_to_host(ctx, (const VkImageSubresource232 *)UlongToPtr(in->pSubresource), 1); + out->imageSubresource = in->imageSubresource; if (in->pNext) FIXME("Unexpected pNext\n"); }

-static inline void convert_VkSubresourceLayout_win32_to_host(const VkSubresourceLayout32 *in, VkSubresourceLayout *out) +static const VkImageSubresource2 *convert_VkImageSubresource2_array_win32_to_host(struct conversion_context *ctx, const VkImageSubresource232 *in, uint32_t count) { - if (!in) return; + VkImageSubresource2 *out; + unsigned int i;

- out->offset = in->offset; - out->size = in->size; - out->rowPitch = in->rowPitch; - out->arrayPitch = in->arrayPitch; - out->depthPitch = in->depthPitch; + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkImageSubresource2_win32_to_host(&in[i], &out[i]); + } + + return out; }

-static inline void convert_VkSubresourceLayout_host_to_win32(const VkSubresourceLayout *in, VkSubresourceLayout32 *out) +static void convert_VkDeviceImageSubresourceInfo_win32_to_host(struct conversion_context *ctx, const VkDeviceImageSubresourceInfo32 *in, VkDeviceImageSubresourceInfo *out) { if (!in) return;

- out->offset = in->offset; - out->size = in->size; - out->rowPitch = in->rowPitch; - out->arrayPitch = in->arrayPitch; - out->depthPitch = in->depthPitch; + out->sType = in->sType; + out->pNext = NULL; + out->pCreateInfo = convert_VkImageCreateInfo_array_win32_to_host(ctx, (const VkImageCreateInfo32 *)UlongToPtr(in->pCreateInfo), 1); + out->pSubresource = convert_VkImageSubresource2_array_win32_to_host(ctx, (const VkImageSubresource232 *)UlongToPtr(in->pSubresource), 1); + if (in->pNext) + FIXME("Unexpected pNext\n"); }

-static inline void convert_VkSubresourceLayout2_win32_to_host(struct conversion_context *ctx, const VkSubresourceLayout232 *in, VkSubresourceLayout2 *out) +static void convert_VkSubresourceLayout2_win32_to_host(struct conversion_context *ctx, const VkSubresourceLayout232 *in, VkSubresourceLayout2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -27759,7 +27731,18 @@ static inline void convert_VkSubresourceLayout2_win32_to_host(struct conversion_ } }

-static inline void convert_VkSubresourceLayout2_host_to_win32(const VkSubresourceLayout2 *in, VkSubresourceLayout232 *out) +static void convert_VkSubresourceLayout_host_to_win32(const VkSubresourceLayout *in, VkSubresourceLayout32 *out) +{ + if (!in) return; + + out->offset = in->offset; + out->size = in->size; + out->rowPitch = in->rowPitch; + out->arrayPitch = in->arrayPitch; + out->depthPitch = in->depthPitch; +} + +static void convert_VkSubresourceLayout2_host_to_win32(const VkSubresourceLayout2 *in, VkSubresourceLayout232 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -27798,7 +27781,7 @@ static inline void convert_VkSubresourceLayout2_host_to_win32(const VkSubresourc }

#ifdef _WIN64 -static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out) +static void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out) { if (!in) return;

@@ -27808,7 +27791,7 @@ static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win64_to_host( } #endif /* _WIN64 */

-static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo32 *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out) +static void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host(const VkDeviceMemoryOpaqueCaptureAddressInfo32 *in, VkDeviceMemoryOpaqueCaptureAddressInfo *out) { if (!in) return;

@@ -27819,7 +27802,7 @@ static inline void convert_VkDeviceMemoryOpaqueCaptureAddressInfo_win32_to_host( FIXME("Unexpected pNext\n"); }

-static inline void convert_VkMicromapVersionInfoEXT_win32_to_host(const VkMicromapVersionInfoEXT32 *in, VkMicromapVersionInfoEXT *out) +static void convert_VkMicromapVersionInfoEXT_win32_to_host(const VkMicromapVersionInfoEXT32 *in, VkMicromapVersionInfoEXT *out) { if (!in) return;

@@ -27830,7 +27813,7 @@ static inline void convert_VkMicromapVersionInfoEXT_win32_to_host(const VkMicrom FIXME("Unexpected pNext\n"); }

-static inline void convert_VkDeviceQueueInfo2_win32_to_host(const VkDeviceQueueInfo232 *in, VkDeviceQueueInfo2 *out) +static void convert_VkDeviceQueueInfo2_win32_to_host(const VkDeviceQueueInfo232 *in, VkDeviceQueueInfo2 *out) { if (!in) return;

@@ -27843,7 +27826,7 @@ static inline void convert_VkDeviceQueueInfo2_win32_to_host(const VkDeviceQueueI FIXME("Unexpected pNext\n"); }

-static inline const VkTensorCreateInfoARM *convert_VkTensorCreateInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorCreateInfoARM32 *in, uint32_t count) +static const VkTensorCreateInfoARM *convert_VkTensorCreateInfoARM_array_win32_to_host(struct conversion_context *ctx, const VkTensorCreateInfoARM32 *in, uint32_t count) { VkTensorCreateInfoARM *out; unsigned int i; @@ -27859,7 +27842,7 @@ static inline const VkTensorCreateInfoARM *convert_VkTensorCreateInfoARM_array_w return out; }

-static inline void convert_VkDeviceTensorMemoryRequirementsARM_win32_to_host(struct conversion_context *ctx, const VkDeviceTensorMemoryRequirementsARM32 *in, VkDeviceTensorMemoryRequirementsARM *out) +static void convert_VkDeviceTensorMemoryRequirementsARM_win32_to_host(struct conversion_context *ctx, const VkDeviceTensorMemoryRequirementsARM32 *in, VkDeviceTensorMemoryRequirementsARM *out) { if (!in) return;

@@ -27870,7 +27853,7 @@ static inline void convert_VkDeviceTensorMemoryRequirementsARM_win32_to_host(str FIXME("Unexpected pNext\n"); }

-static inline void convert_VkTilePropertiesQCOM_win32_to_host(const VkTilePropertiesQCOM32 *in, VkTilePropertiesQCOM *out) +static void convert_VkTilePropertiesQCOM_win32_to_host(const VkTilePropertiesQCOM32 *in, VkTilePropertiesQCOM *out) { if (!in) return;

@@ -27883,7 +27866,7 @@ static inline void convert_VkTilePropertiesQCOM_win32_to_host(const VkTileProper FIXME("Unexpected pNext\n"); }

-static inline void convert_VkTilePropertiesQCOM_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out) +static void convert_VkTilePropertiesQCOM_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out) { if (!in) return;

@@ -27892,7 +27875,7 @@ static inline void convert_VkTilePropertiesQCOM_host_to_win32(const VkTileProper out->origin = in->origin; }

-static inline void convert_VkVideoEncodeSessionParametersGetInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeSessionParametersGetInfoKHR32 *in, VkVideoEncodeSessionParametersGetInfoKHR *out) +static void convert_VkVideoEncodeSessionParametersGetInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeSessionParametersGetInfoKHR32 *in, VkVideoEncodeSessionParametersGetInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -27928,7 +27911,7 @@ static inline void convert_VkVideoEncodeSessionParametersGetInfoKHR_win32_to_hos } }

-static inline void convert_VkVideoEncodeSessionParametersFeedbackInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeSessionParametersFeedbackInfoKHR32 *in, VkVideoEncodeSessionParametersFeedbackInfoKHR *out) +static void convert_VkVideoEncodeSessionParametersFeedbackInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeSessionParametersFeedbackInfoKHR32 *in, VkVideoEncodeSessionParametersFeedbackInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -27958,7 +27941,7 @@ static inline void convert_VkVideoEncodeSessionParametersFeedbackInfoKHR_win32_t } }

-static inline void convert_VkVideoEncodeSessionParametersFeedbackInfoKHR_host_to_win32(const VkVideoEncodeSessionParametersFeedbackInfoKHR *in, VkVideoEncodeSessionParametersFeedbackInfoKHR32 *out) +static void convert_VkVideoEncodeSessionParametersFeedbackInfoKHR_host_to_win32(const VkVideoEncodeSessionParametersFeedbackInfoKHR *in, VkVideoEncodeSessionParametersFeedbackInfoKHR32 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -27987,7 +27970,7 @@ static inline void convert_VkVideoEncodeSessionParametersFeedbackInfoKHR_host_to } }

-static inline VkTilePropertiesQCOM *convert_VkTilePropertiesQCOM_array_win32_to_host(struct conversion_context *ctx, const VkTilePropertiesQCOM32 *in, uint32_t count) +static VkTilePropertiesQCOM *convert_VkTilePropertiesQCOM_array_win32_to_host(struct conversion_context *ctx, const VkTilePropertiesQCOM32 *in, uint32_t count) { VkTilePropertiesQCOM *out; unsigned int i; @@ -28003,7 +27986,7 @@ static inline VkTilePropertiesQCOM *convert_VkTilePropertiesQCOM_array_win32_to_ return out; }

-static inline void convert_VkTilePropertiesQCOM_array_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out, uint32_t count) +static void convert_VkTilePropertiesQCOM_array_host_to_win32(const VkTilePropertiesQCOM *in, VkTilePropertiesQCOM32 *out, uint32_t count) { unsigned int i;

@@ -28015,7 +27998,7 @@ static inline void convert_VkTilePropertiesQCOM_array_host_to_win32(const VkTile } }

-static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *in, VkGeneratedCommandsMemoryRequirementsInfoEXT *out) +static void convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_win32_to_host(struct conversion_context *ctx, const VkGeneratedCommandsMemoryRequirementsInfoEXT32 *in, VkGeneratedCommandsMemoryRequirementsInfoEXT *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -28063,7 +28046,7 @@ static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoEXT_win32_to } }

-static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV32 *in, VkGeneratedCommandsMemoryRequirementsInfoNV *out) +static void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_host(const VkGeneratedCommandsMemoryRequirementsInfoNV32 *in, VkGeneratedCommandsMemoryRequirementsInfoNV *out) { if (!in) return;

@@ -28077,7 +28060,7 @@ static inline void convert_VkGeneratedCommandsMemoryRequirementsInfoNV_win32_to_ FIXME("Unexpected pNext\n"); }

-static inline void convert_VkImageMemoryRequirementsInfo2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryRequirementsInfo232 *in, VkImageMemoryRequirementsInfo2 *out) +static void convert_VkImageMemoryRequirementsInfo2_win32_to_host(struct conversion_context *ctx, const VkImageMemoryRequirementsInfo232 *in, VkImageMemoryRequirementsInfo2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -28110,7 +28093,7 @@ static inline void convert_VkImageMemoryRequirementsInfo2_win32_to_host(struct c } }

-static inline void convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageCaptureDescriptorDataInfoEXT32 *in, VkImageCaptureDescriptorDataInfoEXT *out) +static void convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageCaptureDescriptorDataInfoEXT32 *in, VkImageCaptureDescriptorDataInfoEXT *out) { if (!in) return;

@@ -28121,7 +28104,7 @@ static inline void convert_VkImageCaptureDescriptorDataInfoEXT_win32_to_host(con FIXME("Unexpected pNext\n"); }

-static inline void convert_VkSparseImageMemoryRequirements_array_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out, uint32_t count) +static void convert_VkSparseImageMemoryRequirements_array_host_to_win32(const VkSparseImageMemoryRequirements *in, VkSparseImageMemoryRequirements32 *out, uint32_t count) { unsigned int i;

@@ -28133,7 +28116,7 @@ static inline void convert_VkSparseImageMemoryRequirements_array_host_to_win32(c } }

-static inline void convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(const VkImageSparseMemoryRequirementsInfo232 *in, VkImageSparseMemoryRequirementsInfo2 *out) +static void convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(const VkImageSparseMemoryRequirementsInfo232 *in, VkImageSparseMemoryRequirementsInfo2 *out) { if (!in) return;

@@ -28144,7 +28127,18 @@ static inline void convert_VkImageSparseMemoryRequirementsInfo2_win32_to_host(co FIXME("Unexpected pNext\n"); }

-static inline void convert_VkImageViewAddressPropertiesNVX_win32_to_host(const VkImageViewAddressPropertiesNVX32 *in, VkImageViewAddressPropertiesNVX *out) +static void convert_VkSubresourceLayout_win32_to_host(const VkSubresourceLayout32 *in, VkSubresourceLayout *out) +{ + if (!in) return; + + out->offset = in->offset; + out->size = in->size; + out->rowPitch = in->rowPitch; + out->arrayPitch = in->arrayPitch; + out->depthPitch = in->depthPitch; +} + +static void convert_VkImageViewAddressPropertiesNVX_win32_to_host(const VkImageViewAddressPropertiesNVX32 *in, VkImageViewAddressPropertiesNVX *out) { if (!in) return;

@@ -28154,7 +28148,7 @@ static inline void convert_VkImageViewAddressPropertiesNVX_win32_to_host(const V FIXME("Unexpected pNext\n"); }

-static inline void convert_VkImageViewAddressPropertiesNVX_host_to_win32(const VkImageViewAddressPropertiesNVX *in, VkImageViewAddressPropertiesNVX32 *out) +static void convert_VkImageViewAddressPropertiesNVX_host_to_win32(const VkImageViewAddressPropertiesNVX *in, VkImageViewAddressPropertiesNVX32 *out) { if (!in) return;

@@ -28162,7 +28156,7 @@ static inline void convert_VkImageViewAddressPropertiesNVX_host_to_win32(const V out->size = in->size; }

-static inline void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageViewHandleInfoNVX32 *in, VkImageViewHandleInfoNVX *out) +static void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageViewHandleInfoNVX32 *in, VkImageViewHandleInfoNVX *out) { if (!in) return;

@@ -28175,7 +28169,7 @@ static inline void convert_VkImageViewHandleInfoNVX_win32_to_host(const VkImageV FIXME("Unexpected pNext\n"); }

-static inline void convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageViewCaptureDescriptorDataInfoEXT32 *in, VkImageViewCaptureDescriptorDataInfoEXT *out) +static void convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host(const VkImageViewCaptureDescriptorDataInfoEXT32 *in, VkImageViewCaptureDescriptorDataInfoEXT *out) { if (!in) return;

@@ -28186,17 +28180,45 @@ static inline void convert_VkImageViewCaptureDescriptorDataInfoEXT_win32_to_host FIXME("Unexpected pNext\n"); }

-static inline void convert_VkLatencyTimingsFrameReportNV_win32_to_host(const VkLatencyTimingsFrameReportNV32 *in, VkLatencyTimingsFrameReportNV *out) +static void convert_VkLatencyTimingsFrameReportNV_win32_to_host(const VkLatencyTimingsFrameReportNV32 *in, VkLatencyTimingsFrameReportNV *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + if (in->pNext) + FIXME("Unexpected pNext\n"); +} + +static VkLatencyTimingsFrameReportNV *convert_VkLatencyTimingsFrameReportNV_array_win32_to_host(struct conversion_context *ctx, const VkLatencyTimingsFrameReportNV32 *in, uint32_t count) +{ + VkLatencyTimingsFrameReportNV *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkLatencyTimingsFrameReportNV_win32_to_host(&in[i], &out[i]); + } + + return out; +} + +static void convert_VkGetLatencyMarkerInfoNV_win32_to_host(struct conversion_context *ctx, const VkGetLatencyMarkerInfoNV32 *in, VkGetLatencyMarkerInfoNV *out) { if (!in) return;

out->sType = in->sType; out->pNext = NULL; + out->timingCount = in->timingCount; + out->pTimings = convert_VkLatencyTimingsFrameReportNV_array_win32_to_host(ctx, (VkLatencyTimingsFrameReportNV32 *)UlongToPtr(in->pTimings), in->timingCount); if (in->pNext) FIXME("Unexpected pNext\n"); }

-static inline void convert_VkLatencyTimingsFrameReportNV_host_to_win32(const VkLatencyTimingsFrameReportNV *in, VkLatencyTimingsFrameReportNV32 *out) +static void convert_VkLatencyTimingsFrameReportNV_host_to_win32(const VkLatencyTimingsFrameReportNV *in, VkLatencyTimingsFrameReportNV32 *out) { if (!in) return;

@@ -28216,23 +28238,7 @@ static inline void convert_VkLatencyTimingsFrameReportNV_host_to_win32(const VkL out->gpuRenderEndTimeUs = in->gpuRenderEndTimeUs; }

-static inline VkLatencyTimingsFrameReportNV *convert_VkLatencyTimingsFrameReportNV_array_win32_to_host(struct conversion_context *ctx, const VkLatencyTimingsFrameReportNV32 *in, uint32_t count) -{ - VkLatencyTimingsFrameReportNV *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkLatencyTimingsFrameReportNV_win32_to_host(&in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkLatencyTimingsFrameReportNV_array_host_to_win32(const VkLatencyTimingsFrameReportNV *in, VkLatencyTimingsFrameReportNV32 *out, uint32_t count) +static void convert_VkLatencyTimingsFrameReportNV_array_host_to_win32(const VkLatencyTimingsFrameReportNV *in, VkLatencyTimingsFrameReportNV32 *out, uint32_t count) { unsigned int i;

@@ -28244,19 +28250,7 @@ static inline void convert_VkLatencyTimingsFrameReportNV_array_host_to_win32(con } }

-static inline void convert_VkGetLatencyMarkerInfoNV_win32_to_host(struct conversion_context *ctx, const VkGetLatencyMarkerInfoNV32 *in, VkGetLatencyMarkerInfoNV *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - out->timingCount = in->timingCount; - out->pTimings = convert_VkLatencyTimingsFrameReportNV_array_win32_to_host(ctx, (VkLatencyTimingsFrameReportNV32 *)UlongToPtr(in->pTimings), in->timingCount); - if (in->pNext) - FIXME("Unexpected pNext\n"); -} - -static inline void convert_VkGetLatencyMarkerInfoNV_host_to_win32(const VkGetLatencyMarkerInfoNV *in, VkGetLatencyMarkerInfoNV32 *out) +static void convert_VkGetLatencyMarkerInfoNV_host_to_win32(const VkGetLatencyMarkerInfoNV *in, VkGetLatencyMarkerInfoNV32 *out) { if (!in) return;

@@ -28264,7 +28258,7 @@ static inline void convert_VkGetLatencyMarkerInfoNV_host_to_win32(const VkGetLat convert_VkLatencyTimingsFrameReportNV_array_host_to_win32(in->pTimings, (VkLatencyTimingsFrameReportNV32 *)UlongToPtr(out->pTimings), in->timingCount); }

-static inline void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const VkMemoryHostPointerPropertiesEXT32 *in, VkMemoryHostPointerPropertiesEXT *out) +static void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const VkMemoryHostPointerPropertiesEXT32 *in, VkMemoryHostPointerPropertiesEXT *out) { if (!in) return;

@@ -28274,14 +28268,14 @@ static inline void convert_VkMemoryHostPointerPropertiesEXT_win32_to_host(const FIXME("Unexpected pNext\n"); }

-static inline void convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(const VkMemoryHostPointerPropertiesEXT *in, VkMemoryHostPointerPropertiesEXT32 *out) +static void convert_VkMemoryHostPointerPropertiesEXT_host_to_win32(const VkMemoryHostPointerPropertiesEXT *in, VkMemoryHostPointerPropertiesEXT32 *out) { if (!in) return;

out->memoryTypeBits = in->memoryTypeBits; }

-static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT32 *in, VkMicromapBuildSizesInfoEXT *out) +static void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMicromapBuildSizesInfoEXT32 *in, VkMicromapBuildSizesInfoEXT *out) { if (!in) return;

@@ -28294,7 +28288,7 @@ static inline void convert_VkMicromapBuildSizesInfoEXT_win32_to_host(const VkMic FIXME("Unexpected pNext\n"); }

-static inline void convert_VkMicromapBuildSizesInfoEXT_host_to_win32(const VkMicromapBuildSizesInfoEXT *in, VkMicromapBuildSizesInfoEXT32 *out) +static void convert_VkMicromapBuildSizesInfoEXT_host_to_win32(const VkMicromapBuildSizesInfoEXT *in, VkMicromapBuildSizesInfoEXT32 *out) { if (!in) return;

@@ -28303,7 +28297,13 @@ static inline void convert_VkMicromapBuildSizesInfoEXT_host_to_win32(const VkMic out->discardable = in->discardable; }

-static inline void convert_VkPerformanceValueDataINTEL_host_to_win32(const VkPerformanceValueDataINTEL *in, VkPerformanceValueDataINTEL32 *out, VkFlags selector) +static void convert_VkPartitionedAccelerationStructureInstancesInputNV_host_to_win32(const VkPartitionedAccelerationStructureInstancesInputNV *in, const VkPartitionedAccelerationStructureInstancesInputNV32 *out) +{ + if (!in) return; + +} + +static void convert_VkPerformanceValueDataINTEL_host_to_win32(const VkPerformanceValueDataINTEL *in, VkPerformanceValueDataINTEL32 *out, VkFlags selector) { if (!in) return;

@@ -28317,7 +28317,7 @@ static inline void convert_VkPerformanceValueDataINTEL_host_to_win32(const VkPer out->valueBool = in->valueBool; }

-static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerformanceValueINTEL *in, VkPerformanceValueINTEL32 *out) +static void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerformanceValueINTEL *in, VkPerformanceValueINTEL32 *out) { if (!in) return;

@@ -28325,7 +28325,7 @@ static inline void convert_VkPerformanceValueINTEL_host_to_win32(const VkPerform convert_VkPerformanceValueDataINTEL_host_to_win32(&in->data, &out->data, in->type); }

-static inline void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_win32_to_host(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV *out) +static void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_win32_to_host(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV *out) { if (!in) return;

@@ -28335,23 +28335,7 @@ static inline void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_win FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_host_to_win32(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *out) -{ - if (!in) return; - - out->MGranularity = in->MGranularity; - out->NGranularity = in->NGranularity; - out->KGranularity = in->KGranularity; - out->AType = in->AType; - out->BType = in->BType; - out->CType = in->CType; - out->ResultType = in->ResultType; - out->saturatingAccumulation = in->saturatingAccumulation; - out->scope = in->scope; - out->workgroupInvocations = in->workgroupInvocations; -} - -static inline VkCooperativeMatrixFlexibleDimensionsPropertiesNV *convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *in, uint32_t count) +static VkCooperativeMatrixFlexibleDimensionsPropertiesNV *convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *in, uint32_t count) { VkCooperativeMatrixFlexibleDimensionsPropertiesNV *out; unsigned int i; @@ -28367,7 +28351,23 @@ static inline VkCooperativeMatrixFlexibleDimensionsPropertiesNV *convert_VkCoope return out; }

-static inline void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_array_host_to_win32(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *out, uint32_t count) +static void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_host_to_win32(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *out) +{ + if (!in) return; + + out->MGranularity = in->MGranularity; + out->NGranularity = in->NGranularity; + out->KGranularity = in->KGranularity; + out->AType = in->AType; + out->BType = in->BType; + out->CType = in->CType; + out->ResultType = in->ResultType; + out->saturatingAccumulation = in->saturatingAccumulation; + out->scope = in->scope; + out->workgroupInvocations = in->workgroupInvocations; +} + +static void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_array_host_to_win32(const VkCooperativeMatrixFlexibleDimensionsPropertiesNV *in, VkCooperativeMatrixFlexibleDimensionsPropertiesNV32 *out, uint32_t count) { unsigned int i;

@@ -28379,7 +28379,7 @@ static inline void convert_VkCooperativeMatrixFlexibleDimensionsPropertiesNV_arr } }

-static inline void convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(const VkCooperativeMatrixPropertiesKHR32 *in, VkCooperativeMatrixPropertiesKHR *out) +static void convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(const VkCooperativeMatrixPropertiesKHR32 *in, VkCooperativeMatrixPropertiesKHR *out) { if (!in) return;

@@ -28389,22 +28389,7 @@ static inline void convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(const FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCooperativeMatrixPropertiesKHR_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out) -{ - if (!in) return; - - out->MSize = in->MSize; - out->NSize = in->NSize; - out->KSize = in->KSize; - out->AType = in->AType; - out->BType = in->BType; - out->CType = in->CType; - out->ResultType = in->ResultType; - out->saturatingAccumulation = in->saturatingAccumulation; - out->scope = in->scope; -} - -static inline VkCooperativeMatrixPropertiesKHR *convert_VkCooperativeMatrixPropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesKHR32 *in, uint32_t count) +static VkCooperativeMatrixPropertiesKHR *convert_VkCooperativeMatrixPropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesKHR32 *in, uint32_t count) { VkCooperativeMatrixPropertiesKHR *out; unsigned int i; @@ -28417,10 +28402,25 @@ static inline VkCooperativeMatrixPropertiesKHR *convert_VkCooperativeMatrixPrope convert_VkCooperativeMatrixPropertiesKHR_win32_to_host(&in[i], &out[i]); }

- return out; + return out; +} + +static void convert_VkCooperativeMatrixPropertiesKHR_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out) +{ + if (!in) return; + + out->MSize = in->MSize; + out->NSize = in->NSize; + out->KSize = in->KSize; + out->AType = in->AType; + out->BType = in->BType; + out->CType = in->CType; + out->ResultType = in->ResultType; + out->saturatingAccumulation = in->saturatingAccumulation; + out->scope = in->scope; }

-static inline void convert_VkCooperativeMatrixPropertiesKHR_array_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out, uint32_t count) +static void convert_VkCooperativeMatrixPropertiesKHR_array_host_to_win32(const VkCooperativeMatrixPropertiesKHR *in, VkCooperativeMatrixPropertiesKHR32 *out, uint32_t count) { unsigned int i;

@@ -28432,7 +28432,7 @@ static inline void convert_VkCooperativeMatrixPropertiesKHR_array_host_to_win32( } }

-static inline void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const VkCooperativeMatrixPropertiesNV32 *in, VkCooperativeMatrixPropertiesNV *out) +static void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const VkCooperativeMatrixPropertiesNV32 *in, VkCooperativeMatrixPropertiesNV *out) { if (!in) return;

@@ -28442,21 +28442,7 @@ static inline void convert_VkCooperativeMatrixPropertiesNV_win32_to_host(const V FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCooperativeMatrixPropertiesNV_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out) -{ - if (!in) return; - - out->MSize = in->MSize; - out->NSize = in->NSize; - out->KSize = in->KSize; - out->AType = in->AType; - out->BType = in->BType; - out->CType = in->CType; - out->DType = in->DType; - out->scope = in->scope; -} - -static inline VkCooperativeMatrixPropertiesNV *convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesNV32 *in, uint32_t count) +static VkCooperativeMatrixPropertiesNV *convert_VkCooperativeMatrixPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeMatrixPropertiesNV32 *in, uint32_t count) { VkCooperativeMatrixPropertiesNV *out; unsigned int i; @@ -28472,7 +28458,21 @@ static inline VkCooperativeMatrixPropertiesNV *convert_VkCooperativeMatrixProper return out; }

-static inline void convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out, uint32_t count) +static void convert_VkCooperativeMatrixPropertiesNV_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out) +{ + if (!in) return; + + out->MSize = in->MSize; + out->NSize = in->NSize; + out->KSize = in->KSize; + out->AType = in->AType; + out->BType = in->BType; + out->CType = in->CType; + out->DType = in->DType; + out->scope = in->scope; +} + +static void convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(const VkCooperativeMatrixPropertiesNV *in, VkCooperativeMatrixPropertiesNV32 *out, uint32_t count) { unsigned int i;

@@ -28484,7 +28484,7 @@ static inline void convert_VkCooperativeMatrixPropertiesNV_array_host_to_win32(c } }

-static inline void convert_VkCooperativeVectorPropertiesNV_win32_to_host(const VkCooperativeVectorPropertiesNV32 *in, VkCooperativeVectorPropertiesNV *out) +static void convert_VkCooperativeVectorPropertiesNV_win32_to_host(const VkCooperativeVectorPropertiesNV32 *in, VkCooperativeVectorPropertiesNV *out) { if (!in) return;

@@ -28500,19 +28500,7 @@ static inline void convert_VkCooperativeVectorPropertiesNV_win32_to_host(const V FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCooperativeVectorPropertiesNV_host_to_win32(const VkCooperativeVectorPropertiesNV *in, VkCooperativeVectorPropertiesNV32 *out) -{ - if (!in) return; - - out->inputType = in->inputType; - out->inputInterpretation = in->inputInterpretation; - out->matrixInterpretation = in->matrixInterpretation; - out->biasInterpretation = in->biasInterpretation; - out->resultType = in->resultType; - out->transpose = in->transpose; -} - -static inline VkCooperativeVectorPropertiesNV *convert_VkCooperativeVectorPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeVectorPropertiesNV32 *in, uint32_t count) +static VkCooperativeVectorPropertiesNV *convert_VkCooperativeVectorPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkCooperativeVectorPropertiesNV32 *in, uint32_t count) { VkCooperativeVectorPropertiesNV *out; unsigned int i; @@ -28528,7 +28516,19 @@ static inline VkCooperativeVectorPropertiesNV *convert_VkCooperativeVectorProper return out; }

-static inline void convert_VkCooperativeVectorPropertiesNV_array_host_to_win32(const VkCooperativeVectorPropertiesNV *in, VkCooperativeVectorPropertiesNV32 *out, uint32_t count) +static void convert_VkCooperativeVectorPropertiesNV_host_to_win32(const VkCooperativeVectorPropertiesNV *in, VkCooperativeVectorPropertiesNV32 *out) +{ + if (!in) return; + + out->inputType = in->inputType; + out->inputInterpretation = in->inputInterpretation; + out->matrixInterpretation = in->matrixInterpretation; + out->biasInterpretation = in->biasInterpretation; + out->resultType = in->resultType; + out->transpose = in->transpose; +} + +static void convert_VkCooperativeVectorPropertiesNV_array_host_to_win32(const VkCooperativeVectorPropertiesNV *in, VkCooperativeVectorPropertiesNV32 *out, uint32_t count) { unsigned int i;

@@ -28540,7 +28540,7 @@ static inline void convert_VkCooperativeVectorPropertiesNV_array_host_to_win32(c } }

-static inline void convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalBufferInfo32 *in, VkPhysicalDeviceExternalBufferInfo *out) +static void convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalBufferInfo32 *in, VkPhysicalDeviceExternalBufferInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -28575,7 +28575,7 @@ static inline void convert_VkPhysicalDeviceExternalBufferInfo_win32_to_host(stru } }

-static inline void convert_VkExternalBufferProperties_win32_to_host(const VkExternalBufferProperties32 *in, VkExternalBufferProperties *out) +static void convert_VkExternalBufferProperties_win32_to_host(const VkExternalBufferProperties32 *in, VkExternalBufferProperties *out) { if (!in) return;

@@ -28585,14 +28585,14 @@ static inline void convert_VkExternalBufferProperties_win32_to_host(const VkExte FIXME("Unexpected pNext\n"); }

-static inline void convert_VkExternalBufferProperties_host_to_win32(const VkExternalBufferProperties *in, VkExternalBufferProperties32 *out) +static void convert_VkExternalBufferProperties_host_to_win32(const VkExternalBufferProperties *in, VkExternalBufferProperties32 *out) { if (!in) return;

out->externalMemoryProperties = in->externalMemoryProperties; }

-static inline void convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(const VkPhysicalDeviceExternalFenceInfo32 *in, VkPhysicalDeviceExternalFenceInfo *out) +static void convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(const VkPhysicalDeviceExternalFenceInfo32 *in, VkPhysicalDeviceExternalFenceInfo *out) { if (!in) return;

@@ -28603,7 +28603,7 @@ static inline void convert_VkPhysicalDeviceExternalFenceInfo_win32_to_host(const FIXME("Unexpected pNext\n"); }

-static inline void convert_VkExternalFenceProperties_win32_to_host(const VkExternalFenceProperties32 *in, VkExternalFenceProperties *out) +static void convert_VkExternalFenceProperties_win32_to_host(const VkExternalFenceProperties32 *in, VkExternalFenceProperties *out) { if (!in) return;

@@ -28613,7 +28613,7 @@ static inline void convert_VkExternalFenceProperties_win32_to_host(const VkExter FIXME("Unexpected pNext\n"); }

-static inline void convert_VkExternalFenceProperties_host_to_win32(const VkExternalFenceProperties *in, VkExternalFenceProperties32 *out) +static void convert_VkExternalFenceProperties_host_to_win32(const VkExternalFenceProperties *in, VkExternalFenceProperties32 *out) { if (!in) return;

@@ -28622,7 +28622,7 @@ static inline void convert_VkExternalFenceProperties_host_to_win32(const VkExter out->externalFenceFeatures = in->externalFenceFeatures; }

-static inline void convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalSemaphoreInfo32 *in, VkPhysicalDeviceExternalSemaphoreInfo *out) +static void convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalSemaphoreInfo32 *in, VkPhysicalDeviceExternalSemaphoreInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -28656,7 +28656,7 @@ static inline void convert_VkPhysicalDeviceExternalSemaphoreInfo_win32_to_host(s } }

-static inline void convert_VkExternalSemaphoreProperties_win32_to_host(const VkExternalSemaphoreProperties32 *in, VkExternalSemaphoreProperties *out) +static void convert_VkExternalSemaphoreProperties_win32_to_host(const VkExternalSemaphoreProperties32 *in, VkExternalSemaphoreProperties *out) { if (!in) return;

@@ -28666,7 +28666,7 @@ static inline void convert_VkExternalSemaphoreProperties_win32_to_host(const VkE FIXME("Unexpected pNext\n"); }

-static inline void convert_VkExternalSemaphoreProperties_host_to_win32(const VkExternalSemaphoreProperties *in, VkExternalSemaphoreProperties32 *out) +static void convert_VkExternalSemaphoreProperties_host_to_win32(const VkExternalSemaphoreProperties *in, VkExternalSemaphoreProperties32 *out) { if (!in) return;

@@ -28675,7 +28675,7 @@ static inline void convert_VkExternalSemaphoreProperties_host_to_win32(const VkE out->externalSemaphoreFeatures = in->externalSemaphoreFeatures; }

-static inline void convert_VkPhysicalDeviceExternalTensorInfoARM_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalTensorInfoARM32 *in, VkPhysicalDeviceExternalTensorInfoARM *out) +static void convert_VkPhysicalDeviceExternalTensorInfoARM_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceExternalTensorInfoARM32 *in, VkPhysicalDeviceExternalTensorInfoARM *out) { if (!in) return;

@@ -28688,7 +28688,7 @@ static inline void convert_VkPhysicalDeviceExternalTensorInfoARM_win32_to_host(s FIXME("Unexpected pNext\n"); }

-static inline void convert_VkExternalTensorPropertiesARM_win32_to_host(const VkExternalTensorPropertiesARM32 *in, VkExternalTensorPropertiesARM *out) +static void convert_VkExternalTensorPropertiesARM_win32_to_host(const VkExternalTensorPropertiesARM32 *in, VkExternalTensorPropertiesARM *out) { if (!in) return;

@@ -28699,14 +28699,14 @@ static inline void convert_VkExternalTensorPropertiesARM_win32_to_host(const VkE FIXME("Unexpected pNext\n"); }

-static inline void convert_VkExternalTensorPropertiesARM_host_to_win32(const VkExternalTensorPropertiesARM *in, VkExternalTensorPropertiesARM32 *out) +static void convert_VkExternalTensorPropertiesARM_host_to_win32(const VkExternalTensorPropertiesARM *in, VkExternalTensorPropertiesARM32 *out) { if (!in) return;

out->externalMemoryProperties = in->externalMemoryProperties; }

-static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFeatures232 *in, VkPhysicalDeviceFeatures2 *out) +static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFeatures232 *in, VkPhysicalDeviceFeatures2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -31416,7 +31416,7 @@ static inline void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conver } }

-static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDeviceFeatures2 *in, VkPhysicalDeviceFeatures232 *out) +static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDeviceFeatures2 *in, VkPhysicalDeviceFeatures232 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -33689,7 +33689,7 @@ static inline void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysi } }

-static inline void convert_VkFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkFormatProperties232 *in, VkFormatProperties2 *out) +static void convert_VkFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkFormatProperties232 *in, VkFormatProperties2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -33737,7 +33737,7 @@ static inline void convert_VkFormatProperties2_win32_to_host(struct conversion_c } }

-static inline void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2 *in, VkFormatProperties232 *out) +static void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2 *in, VkFormatProperties232 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -33786,7 +33786,7 @@ static inline void convert_VkFormatProperties2_host_to_win32(const VkFormatPrope } }

-static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(const VkPhysicalDeviceFragmentShadingRateKHR32 *in, VkPhysicalDeviceFragmentShadingRateKHR *out) +static void convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host(const VkPhysicalDeviceFragmentShadingRateKHR32 *in, VkPhysicalDeviceFragmentShadingRateKHR *out) { if (!in) return;

@@ -33796,15 +33796,7 @@ static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_win32_to_host( FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out) -{ - if (!in) return; - - out->sampleCounts = in->sampleCounts; - out->fragmentSize = in->fragmentSize; -} - -static inline VkPhysicalDeviceFragmentShadingRateKHR *convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFragmentShadingRateKHR32 *in, uint32_t count) +static VkPhysicalDeviceFragmentShadingRateKHR *convert_VkPhysicalDeviceFragmentShadingRateKHR_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceFragmentShadingRateKHR32 *in, uint32_t count) { VkPhysicalDeviceFragmentShadingRateKHR *out; unsigned int i; @@ -33820,7 +33812,15 @@ static inline VkPhysicalDeviceFragmentShadingRateKHR *convert_VkPhysicalDeviceFr return out; }

-static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out, uint32_t count) +static void convert_VkPhysicalDeviceFragmentShadingRateKHR_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out) +{ + if (!in) return; + + out->sampleCounts = in->sampleCounts; + out->fragmentSize = in->fragmentSize; +} + +static void convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_win32(const VkPhysicalDeviceFragmentShadingRateKHR *in, VkPhysicalDeviceFragmentShadingRateKHR32 *out, uint32_t count) { unsigned int i;

@@ -33832,7 +33832,7 @@ static inline void convert_VkPhysicalDeviceFragmentShadingRateKHR_array_host_to_ } }

-static inline void convert_VkImageFormatProperties_host_to_win32(const VkImageFormatProperties *in, VkImageFormatProperties32 *out) +static void convert_VkImageFormatProperties_host_to_win32(const VkImageFormatProperties *in, VkImageFormatProperties32 *out) { if (!in) return;

@@ -33843,7 +33843,7 @@ static inline void convert_VkImageFormatProperties_host_to_win32(const VkImageFo out->maxResourceSize = in->maxResourceSize; }

-static inline void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceImageFormatInfo232 *in, VkPhysicalDeviceImageFormatInfo2 *out) +static void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceImageFormatInfo232 *in, VkPhysicalDeviceImageFormatInfo2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -33950,7 +33950,7 @@ static inline void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct } }

-static inline void convert_VkImageFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkImageFormatProperties232 *in, VkImageFormatProperties2 *out) +static void convert_VkImageFormatProperties2_win32_to_host(struct conversion_context *ctx, const VkImageFormatProperties232 *in, VkImageFormatProperties2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -34025,7 +34025,7 @@ static inline void convert_VkImageFormatProperties2_win32_to_host(struct convers } }

-static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatProperties2 *in, VkImageFormatProperties232 *out) +static void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatProperties2 *in, VkImageFormatProperties232 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -34101,7 +34101,7 @@ static inline void convert_VkImageFormatProperties2_host_to_win32(const VkImageF } }

-static inline void convert_VkMemoryHeap_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out) +static void convert_VkMemoryHeap_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out) { if (!in) return;

@@ -34109,7 +34109,7 @@ static inline void convert_VkMemoryHeap_host_to_win32(const VkMemoryHeap *in, Vk out->flags = in->flags; }

-static inline void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out, uint32_t count) +static void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap *in, VkMemoryHeap32 *out, uint32_t count) { unsigned int i;

@@ -34121,7 +34121,7 @@ static inline void convert_VkMemoryHeap_array_host_to_win32(const VkMemoryHeap * } }

-static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const VkPhysicalDeviceMemoryProperties *in, VkPhysicalDeviceMemoryProperties32 *out) +static void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const VkPhysicalDeviceMemoryProperties *in, VkPhysicalDeviceMemoryProperties32 *out) { if (!in) return;

@@ -34131,7 +34131,7 @@ static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win32(const convert_VkMemoryHeap_array_host_to_win32(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS); }

-static inline void convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceMemoryProperties232 *in, VkPhysicalDeviceMemoryProperties2 *out) +static void convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceMemoryProperties232 *in, VkPhysicalDeviceMemoryProperties2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -34161,7 +34161,7 @@ static inline void convert_VkPhysicalDeviceMemoryProperties2_win32_to_host(struc } }

-static inline void convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(const VkPhysicalDeviceMemoryProperties2 *in, VkPhysicalDeviceMemoryProperties232 *out) +static void convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(const VkPhysicalDeviceMemoryProperties2 *in, VkPhysicalDeviceMemoryProperties232 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -34190,7 +34190,7 @@ static inline void convert_VkPhysicalDeviceMemoryProperties2_host_to_win32(const } }

-static inline void convert_VkMultisamplePropertiesEXT_win32_to_host(const VkMultisamplePropertiesEXT32 *in, VkMultisamplePropertiesEXT *out) +static void convert_VkMultisamplePropertiesEXT_win32_to_host(const VkMultisamplePropertiesEXT32 *in, VkMultisamplePropertiesEXT *out) { if (!in) return;

@@ -34200,14 +34200,14 @@ static inline void convert_VkMultisamplePropertiesEXT_win32_to_host(const VkMult FIXME("Unexpected pNext\n"); }

-static inline void convert_VkMultisamplePropertiesEXT_host_to_win32(const VkMultisamplePropertiesEXT *in, VkMultisamplePropertiesEXT32 *out) +static void convert_VkMultisamplePropertiesEXT_host_to_win32(const VkMultisamplePropertiesEXT *in, VkMultisamplePropertiesEXT32 *out) { if (!in) return;

out->maxSampleLocationGridSize = in->maxSampleLocationGridSize; }

-static inline void convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(const VkOpticalFlowImageFormatInfoNV32 *in, VkOpticalFlowImageFormatInfoNV *out) +static void convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(const VkOpticalFlowImageFormatInfoNV32 *in, VkOpticalFlowImageFormatInfoNV *out) { if (!in) return;

@@ -34218,7 +34218,7 @@ static inline void convert_VkOpticalFlowImageFormatInfoNV_win32_to_host(const Vk FIXME("Unexpected pNext\n"); }

-static inline void convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(const VkOpticalFlowImageFormatPropertiesNV32 *in, VkOpticalFlowImageFormatPropertiesNV *out) +static void convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(const VkOpticalFlowImageFormatPropertiesNV32 *in, VkOpticalFlowImageFormatPropertiesNV *out) { if (!in) return;

@@ -34228,14 +34228,7 @@ static inline void convert_VkOpticalFlowImageFormatPropertiesNV_win32_to_host(co FIXME("Unexpected pNext\n"); }

-static inline void convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out) -{ - if (!in) return; - - out->format = in->format; -} - -static inline VkOpticalFlowImageFormatPropertiesNV *convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowImageFormatPropertiesNV32 *in, uint32_t count) +static VkOpticalFlowImageFormatPropertiesNV *convert_VkOpticalFlowImageFormatPropertiesNV_array_win32_to_host(struct conversion_context *ctx, const VkOpticalFlowImageFormatPropertiesNV32 *in, uint32_t count) { VkOpticalFlowImageFormatPropertiesNV *out; unsigned int i; @@ -34251,7 +34244,14 @@ static inline VkOpticalFlowImageFormatPropertiesNV *convert_VkOpticalFlowImageFo return out; }

-static inline void convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out, uint32_t count) +static void convert_VkOpticalFlowImageFormatPropertiesNV_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out) +{ + if (!in) return; + + out->format = in->format; +} + +static void convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_win32(const VkOpticalFlowImageFormatPropertiesNV *in, VkOpticalFlowImageFormatPropertiesNV32 *out, uint32_t count) { unsigned int i;

@@ -34263,7 +34263,7 @@ static inline void convert_VkOpticalFlowImageFormatPropertiesNV_array_host_to_wi } }

-static inline void convert_VkPhysicalDeviceLimits_host_to_win32(const VkPhysicalDeviceLimits *in, VkPhysicalDeviceLimits32 *out) +static void convert_VkPhysicalDeviceLimits_host_to_win32(const VkPhysicalDeviceLimits *in, VkPhysicalDeviceLimits32 *out) { if (!in) return;

@@ -34375,7 +34375,7 @@ static inline void convert_VkPhysicalDeviceLimits_host_to_win32(const VkPhysical out->nonCoherentAtomSize = in->nonCoherentAtomSize; }

-static inline void convert_VkPhysicalDeviceProperties_host_to_win32(const VkPhysicalDeviceProperties *in, VkPhysicalDeviceProperties32 *out) +static void convert_VkPhysicalDeviceProperties_host_to_win32(const VkPhysicalDeviceProperties *in, VkPhysicalDeviceProperties32 *out) { if (!in) return;

@@ -34390,7 +34390,7 @@ static inline void convert_VkPhysicalDeviceProperties_host_to_win32(const VkPhys out->sparseProperties = in->sparseProperties; }

-static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceProperties232 *in, VkPhysicalDeviceProperties2 *out) +static void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceProperties232 *in, VkPhysicalDeviceProperties2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -35307,7 +35307,7 @@ static inline void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conv } }

-static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDeviceProperties2 *in, VkPhysicalDeviceProperties232 *out) +static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDeviceProperties2 *in, VkPhysicalDeviceProperties232 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -36694,7 +36694,7 @@ static inline void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhy } }

-static inline void convert_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM_win32_to_host(const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32 *in, VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *out) +static void convert_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM_win32_to_host(const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM32 *in, VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM *out) { if (!in) return;

@@ -36706,7 +36706,7 @@ static inline void convert_VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineI FIXME("Unexpected pNext\n"); }

-static inline void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_win32_to_host(const VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 *in, VkQueueFamilyDataGraphProcessingEnginePropertiesARM *out) +static void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_win32_to_host(const VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 *in, VkQueueFamilyDataGraphProcessingEnginePropertiesARM *out) { if (!in) return;

@@ -36718,7 +36718,7 @@ static inline void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_w FIXME("Unexpected pNext\n"); }

-static inline void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_host_to_win32(const VkQueueFamilyDataGraphProcessingEnginePropertiesARM *in, VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 *out) +static void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_host_to_win32(const VkQueueFamilyDataGraphProcessingEnginePropertiesARM *in, VkQueueFamilyDataGraphProcessingEnginePropertiesARM32 *out) { if (!in) return;

@@ -36726,7 +36726,7 @@ static inline void convert_VkQueueFamilyDataGraphProcessingEnginePropertiesARM_h out->foreignMemoryHandleTypes = in->foreignMemoryHandleTypes; }

-static inline void convert_VkQueueFamilyDataGraphPropertiesARM_win32_to_host(const VkQueueFamilyDataGraphPropertiesARM32 *in, VkQueueFamilyDataGraphPropertiesARM *out) +static void convert_VkQueueFamilyDataGraphPropertiesARM_win32_to_host(const VkQueueFamilyDataGraphPropertiesARM32 *in, VkQueueFamilyDataGraphPropertiesARM *out) { if (!in) return;

@@ -36738,15 +36738,7 @@ static inline void convert_VkQueueFamilyDataGraphPropertiesARM_win32_to_host(con FIXME("Unexpected pNext\n"); }

-static inline void convert_VkQueueFamilyDataGraphPropertiesARM_host_to_win32(const VkQueueFamilyDataGraphPropertiesARM *in, VkQueueFamilyDataGraphPropertiesARM32 *out) -{ - if (!in) return; - - out->engine = in->engine; - out->operation = in->operation; -} - -static inline VkQueueFamilyDataGraphPropertiesARM *convert_VkQueueFamilyDataGraphPropertiesARM_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyDataGraphPropertiesARM32 *in, uint32_t count) +static VkQueueFamilyDataGraphPropertiesARM *convert_VkQueueFamilyDataGraphPropertiesARM_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyDataGraphPropertiesARM32 *in, uint32_t count) { VkQueueFamilyDataGraphPropertiesARM *out; unsigned int i; @@ -36762,7 +36754,15 @@ static inline VkQueueFamilyDataGraphPropertiesARM *convert_VkQueueFamilyDataGrap return out; }

-static inline void convert_VkQueueFamilyDataGraphPropertiesARM_array_host_to_win32(const VkQueueFamilyDataGraphPropertiesARM *in, VkQueueFamilyDataGraphPropertiesARM32 *out, uint32_t count) +static void convert_VkQueueFamilyDataGraphPropertiesARM_host_to_win32(const VkQueueFamilyDataGraphPropertiesARM *in, VkQueueFamilyDataGraphPropertiesARM32 *out) +{ + if (!in) return; + + out->engine = in->engine; + out->operation = in->operation; +} + +static void convert_VkQueueFamilyDataGraphPropertiesARM_array_host_to_win32(const VkQueueFamilyDataGraphPropertiesARM *in, VkQueueFamilyDataGraphPropertiesARM32 *out, uint32_t count) { unsigned int i;

@@ -36774,7 +36774,7 @@ static inline void convert_VkQueueFamilyDataGraphPropertiesARM_array_host_to_win } }

-static inline void convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(const VkQueryPoolPerformanceCreateInfoKHR32 *in, VkQueryPoolPerformanceCreateInfoKHR *out) +static void convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(const VkQueryPoolPerformanceCreateInfoKHR32 *in, VkQueryPoolPerformanceCreateInfoKHR *out) { if (!in) return;

@@ -36787,7 +36787,7 @@ static inline void convert_VkQueryPoolPerformanceCreateInfoKHR_win32_to_host(con FIXME("Unexpected pNext\n"); }

-static inline void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, VkQueueFamilyProperties2 *out) +static void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, VkQueueFamilyProperties2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -36862,7 +36862,23 @@ static inline void convert_VkQueueFamilyProperties2_win32_to_host(struct convers } }

-static inline void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out) +static VkQueueFamilyProperties2 *convert_VkQueueFamilyProperties2_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, uint32_t count) +{ + VkQueueFamilyProperties2 *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkQueueFamilyProperties2_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -36936,23 +36952,7 @@ static inline void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueF } }

-static inline VkQueueFamilyProperties2 *convert_VkQueueFamilyProperties2_array_win32_to_host(struct conversion_context *ctx, const VkQueueFamilyProperties232 *in, uint32_t count) -{ - VkQueueFamilyProperties2 *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkQueueFamilyProperties2_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkQueueFamilyProperties2_array_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out, uint32_t count) +static void convert_VkQueueFamilyProperties2_array_host_to_win32(const VkQueueFamilyProperties2 *in, VkQueueFamilyProperties232 *out, uint32_t count) { unsigned int i;

@@ -36964,7 +36964,7 @@ static inline void convert_VkQueueFamilyProperties2_array_host_to_win32(const Vk } }

-static inline void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(const VkPhysicalDeviceSparseImageFormatInfo232 *in, VkPhysicalDeviceSparseImageFormatInfo2 *out) +static void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host(const VkPhysicalDeviceSparseImageFormatInfo232 *in, VkPhysicalDeviceSparseImageFormatInfo2 *out) { if (!in) return;

@@ -36979,7 +36979,7 @@ static inline void convert_VkPhysicalDeviceSparseImageFormatInfo2_win32_to_host( FIXME("Unexpected pNext\n"); }

-static inline void convert_VkSparseImageFormatProperties2_win32_to_host(const VkSparseImageFormatProperties232 *in, VkSparseImageFormatProperties2 *out) +static void convert_VkSparseImageFormatProperties2_win32_to_host(const VkSparseImageFormatProperties232 *in, VkSparseImageFormatProperties2 *out) { if (!in) return;

@@ -36989,14 +36989,7 @@ static inline void convert_VkSparseImageFormatProperties2_win32_to_host(const Vk FIXME("Unexpected pNext\n"); }

-static inline void convert_VkSparseImageFormatProperties2_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out) -{ - if (!in) return; - - out->properties = in->properties; -} - -static inline VkSparseImageFormatProperties2 *convert_VkSparseImageFormatProperties2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageFormatProperties232 *in, uint32_t count) +static VkSparseImageFormatProperties2 *convert_VkSparseImageFormatProperties2_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageFormatProperties232 *in, uint32_t count) { VkSparseImageFormatProperties2 *out; unsigned int i; @@ -37012,7 +37005,14 @@ static inline VkSparseImageFormatProperties2 *convert_VkSparseImageFormatPropert return out; }

-static inline void convert_VkSparseImageFormatProperties2_array_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out, uint32_t count) +static void convert_VkSparseImageFormatProperties2_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out) +{ + if (!in) return; + + out->properties = in->properties; +} + +static void convert_VkSparseImageFormatProperties2_array_host_to_win32(const VkSparseImageFormatProperties2 *in, VkSparseImageFormatProperties232 *out, uint32_t count) { unsigned int i;

@@ -37024,7 +37024,7 @@ static inline void convert_VkSparseImageFormatProperties2_array_host_to_win32(co } }

-static inline void convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(const VkFramebufferMixedSamplesCombinationNV32 *in, VkFramebufferMixedSamplesCombinationNV *out) +static void convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host(const VkFramebufferMixedSamplesCombinationNV32 *in, VkFramebufferMixedSamplesCombinationNV *out) { if (!in) return;

@@ -37034,17 +37034,7 @@ static inline void convert_VkFramebufferMixedSamplesCombinationNV_win32_to_host( FIXME("Unexpected pNext\n"); }

-static inline void convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out) -{ - if (!in) return; - - out->coverageReductionMode = in->coverageReductionMode; - out->rasterizationSamples = in->rasterizationSamples; - out->depthStencilSamples = in->depthStencilSamples; - out->colorSamples = in->colorSamples; -} - -static inline VkFramebufferMixedSamplesCombinationNV *convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferMixedSamplesCombinationNV32 *in, uint32_t count) +static VkFramebufferMixedSamplesCombinationNV *convert_VkFramebufferMixedSamplesCombinationNV_array_win32_to_host(struct conversion_context *ctx, const VkFramebufferMixedSamplesCombinationNV32 *in, uint32_t count) { VkFramebufferMixedSamplesCombinationNV *out; unsigned int i; @@ -37060,7 +37050,17 @@ static inline VkFramebufferMixedSamplesCombinationNV *convert_VkFramebufferMixed return out; }

-static inline void convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out, uint32_t count) +static void convert_VkFramebufferMixedSamplesCombinationNV_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out) +{ + if (!in) return; + + out->coverageReductionMode = in->coverageReductionMode; + out->rasterizationSamples = in->rasterizationSamples; + out->depthStencilSamples = in->depthStencilSamples; + out->colorSamples = in->colorSamples; +} + +static void convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_win32(const VkFramebufferMixedSamplesCombinationNV *in, VkFramebufferMixedSamplesCombinationNV32 *out, uint32_t count) { unsigned int i;

@@ -37072,7 +37072,7 @@ static inline void convert_VkFramebufferMixedSamplesCombinationNV_array_host_to_ } }

-static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out) +static void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPhysicalDeviceSurfaceInfo2KHR32 *in, VkPhysicalDeviceSurfaceInfo2KHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -37105,7 +37105,7 @@ static inline void convert_VkPhysicalDeviceSurfaceInfo2KHR_win32_to_unwrapped_ho } }

-static inline void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceCapabilities2KHR32 *in, VkSurfaceCapabilities2KHR *out) +static void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceCapabilities2KHR32 *in, VkSurfaceCapabilities2KHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -37196,7 +37196,7 @@ static inline void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conver } }

-static inline void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapabilities2KHR *in, VkSurfaceCapabilities2KHR32 *out) +static void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapabilities2KHR *in, VkSurfaceCapabilities2KHR32 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -37275,7 +37275,7 @@ static inline void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfa } }

-static inline void convert_VkSurfaceFormat2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, VkSurfaceFormat2KHR *out) +static void convert_VkSurfaceFormat2KHR_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, VkSurfaceFormat2KHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -37305,7 +37305,23 @@ static inline void convert_VkSurfaceFormat2KHR_win32_to_host(struct conversion_c } }

-static inline void convert_VkSurfaceFormat2KHR_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out) +static VkSurfaceFormat2KHR *convert_VkSurfaceFormat2KHR_array_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, uint32_t count) +{ + VkSurfaceFormat2KHR *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkSurfaceFormat2KHR_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkSurfaceFormat2KHR_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -37334,23 +37350,7 @@ static inline void convert_VkSurfaceFormat2KHR_host_to_win32(const VkSurfaceForm } }

-static inline VkSurfaceFormat2KHR *convert_VkSurfaceFormat2KHR_array_win32_to_host(struct conversion_context *ctx, const VkSurfaceFormat2KHR32 *in, uint32_t count) -{ - VkSurfaceFormat2KHR *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkSurfaceFormat2KHR_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkSurfaceFormat2KHR_array_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out, uint32_t count) +static void convert_VkSurfaceFormat2KHR_array_host_to_win32(const VkSurfaceFormat2KHR *in, VkSurfaceFormat2KHR32 *out, uint32_t count) { unsigned int i;

@@ -37362,7 +37362,7 @@ static inline void convert_VkSurfaceFormat2KHR_array_host_to_win32(const VkSurfa } }

-static inline void convert_VkPhysicalDeviceToolProperties_win32_to_host(const VkPhysicalDeviceToolProperties32 *in, VkPhysicalDeviceToolProperties *out) +static void convert_VkPhysicalDeviceToolProperties_win32_to_host(const VkPhysicalDeviceToolProperties32 *in, VkPhysicalDeviceToolProperties *out) { if (!in) return;

@@ -37372,18 +37372,7 @@ static inline void convert_VkPhysicalDeviceToolProperties_win32_to_host(const Vk FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPhysicalDeviceToolProperties_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out) -{ - if (!in) return; - - memcpy(out->name, in->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char)); - memcpy(out->version, in->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char)); - out->purposes = in->purposes; - memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); - memcpy(out->layer, in->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char)); -} - -static inline VkPhysicalDeviceToolProperties *convert_VkPhysicalDeviceToolProperties_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceToolProperties32 *in, uint32_t count) +static VkPhysicalDeviceToolProperties *convert_VkPhysicalDeviceToolProperties_array_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceToolProperties32 *in, uint32_t count) { VkPhysicalDeviceToolProperties *out; unsigned int i; @@ -37399,7 +37388,18 @@ static inline VkPhysicalDeviceToolProperties *convert_VkPhysicalDeviceToolProper return out; }

-static inline void convert_VkPhysicalDeviceToolProperties_array_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out, uint32_t count) +static void convert_VkPhysicalDeviceToolProperties_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out) +{ + if (!in) return; + + memcpy(out->name, in->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char)); + memcpy(out->version, in->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char)); + out->purposes = in->purposes; + memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); + memcpy(out->layer, in->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char)); +} + +static void convert_VkPhysicalDeviceToolProperties_array_host_to_win32(const VkPhysicalDeviceToolProperties *in, VkPhysicalDeviceToolProperties32 *out, uint32_t count) { unsigned int i;

@@ -37411,7 +37411,7 @@ static inline void convert_VkPhysicalDeviceToolProperties_array_host_to_win32(co } }

-static inline void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoCapabilitiesKHR32 *in, VkVideoCapabilitiesKHR *out) +static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoCapabilitiesKHR32 *in, VkVideoCapabilitiesKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -37540,7 +37540,7 @@ static inline void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversio } }

-static inline void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabilitiesKHR *in, VkVideoCapabilitiesKHR32 *out) +static void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabilitiesKHR *in, VkVideoCapabilitiesKHR32 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -37724,7 +37724,7 @@ static inline void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCap } }

-static inline void convert_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR32 *in, VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *out) +static void convert_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR32 *in, VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR *out) { if (!in) return;

@@ -37736,7 +37736,7 @@ static inline void convert_VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR_win32_ FIXME("Unexpected pNext\n"); }

-static inline void convert_VkVideoEncodeQualityLevelPropertiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeQualityLevelPropertiesKHR32 *in, VkVideoEncodeQualityLevelPropertiesKHR *out) +static void convert_VkVideoEncodeQualityLevelPropertiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeQualityLevelPropertiesKHR32 *in, VkVideoEncodeQualityLevelPropertiesKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -37775,7 +37775,7 @@ static inline void convert_VkVideoEncodeQualityLevelPropertiesKHR_win32_to_host( } }

-static inline void convert_VkVideoEncodeQualityLevelPropertiesKHR_host_to_win32(const VkVideoEncodeQualityLevelPropertiesKHR *in, VkVideoEncodeQualityLevelPropertiesKHR32 *out) +static void convert_VkVideoEncodeQualityLevelPropertiesKHR_host_to_win32(const VkVideoEncodeQualityLevelPropertiesKHR *in, VkVideoEncodeQualityLevelPropertiesKHR32 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -37835,7 +37835,7 @@ static inline void convert_VkVideoEncodeQualityLevelPropertiesKHR_host_to_win32( } }

-static inline void convert_VkPhysicalDeviceVideoFormatInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceVideoFormatInfoKHR32 *in, VkPhysicalDeviceVideoFormatInfoKHR *out) +static void convert_VkPhysicalDeviceVideoFormatInfoKHR_win32_to_host(struct conversion_context *ctx, const VkPhysicalDeviceVideoFormatInfoKHR32 *in, VkPhysicalDeviceVideoFormatInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -37869,7 +37869,7 @@ static inline void convert_VkPhysicalDeviceVideoFormatInfoKHR_win32_to_host(stru } }

-static inline void convert_VkVideoFormatPropertiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoFormatPropertiesKHR32 *in, VkVideoFormatPropertiesKHR *out) +static void convert_VkVideoFormatPropertiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoFormatPropertiesKHR32 *in, VkVideoFormatPropertiesKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -37917,7 +37917,23 @@ static inline void convert_VkVideoFormatPropertiesKHR_win32_to_host(struct conve } }

-static inline void convert_VkVideoFormatPropertiesKHR_host_to_win32(const VkVideoFormatPropertiesKHR *in, VkVideoFormatPropertiesKHR32 *out) +static VkVideoFormatPropertiesKHR *convert_VkVideoFormatPropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoFormatPropertiesKHR32 *in, uint32_t count) +{ + VkVideoFormatPropertiesKHR *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkVideoFormatPropertiesKHR_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + +static void convert_VkVideoFormatPropertiesKHR_host_to_win32(const VkVideoFormatPropertiesKHR *in, VkVideoFormatPropertiesKHR32 *out) { const VkBaseInStructure *in_header; VkBaseOutStructure32 *out_header = (void *)out; @@ -37968,23 +37984,7 @@ static inline void convert_VkVideoFormatPropertiesKHR_host_to_win32(const VkVide } }

-static inline VkVideoFormatPropertiesKHR *convert_VkVideoFormatPropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoFormatPropertiesKHR32 *in, uint32_t count) -{ - VkVideoFormatPropertiesKHR *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkVideoFormatPropertiesKHR_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - -static inline void convert_VkVideoFormatPropertiesKHR_array_host_to_win32(const VkVideoFormatPropertiesKHR *in, VkVideoFormatPropertiesKHR32 *out, uint32_t count) +static void convert_VkVideoFormatPropertiesKHR_array_host_to_win32(const VkVideoFormatPropertiesKHR *in, VkVideoFormatPropertiesKHR32 *out, uint32_t count) { unsigned int i;

@@ -37996,7 +37996,7 @@ static inline void convert_VkVideoFormatPropertiesKHR_array_host_to_win32(const } }

-static inline void convert_VkPipelineBinaryDataInfoKHR_win32_to_host(const VkPipelineBinaryDataInfoKHR32 *in, VkPipelineBinaryDataInfoKHR *out) +static void convert_VkPipelineBinaryDataInfoKHR_win32_to_host(const VkPipelineBinaryDataInfoKHR32 *in, VkPipelineBinaryDataInfoKHR *out) { if (!in) return;

@@ -38007,7 +38007,7 @@ static inline void convert_VkPipelineBinaryDataInfoKHR_win32_to_host(const VkPip FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPipelineBinaryKeyKHR_host_to_win32(const VkPipelineBinaryKeyKHR *in, VkPipelineBinaryKeyKHR32 *out) +static void convert_VkPipelineBinaryKeyKHR_host_to_win32(const VkPipelineBinaryKeyKHR *in, VkPipelineBinaryKeyKHR32 *out) { if (!in) return;

@@ -38015,7 +38015,7 @@ static inline void convert_VkPipelineBinaryKeyKHR_host_to_win32(const VkPipeline memcpy(out->key, in->key, VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR * sizeof(uint8_t)); }

-static inline void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPipelineExecutableInfoKHR32 *in, VkPipelineExecutableInfoKHR *out) +static void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPipelineExecutableInfoKHR32 *in, VkPipelineExecutableInfoKHR *out) { if (!in) return;

@@ -38027,7 +38027,7 @@ static inline void convert_VkPipelineExecutableInfoKHR_win32_to_host(const VkPip FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(const VkPipelineExecutableInternalRepresentationKHR32 *in, VkPipelineExecutableInternalRepresentationKHR *out) +static void convert_VkPipelineExecutableInternalRepresentationKHR_win32_to_host(const VkPipelineExecutableInternalRepresentationKHR32 *in, VkPipelineExecutableInternalRepresentationKHR *out) { if (!in) return;

@@ -38037,18 +38037,7 @@ static inline void convert_VkPipelineExecutableInternalRepresentationKHR_win32_t FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out) -{ - if (!in) return; - - memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); - memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); - out->isText = in->isText; - out->dataSize = in->dataSize; - out->pData = PtrToUlong(in->pData); -} - -static inline VkPipelineExecutableInternalRepresentationKHR *convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableInternalRepresentationKHR32 *in, uint32_t count) +static VkPipelineExecutableInternalRepresentationKHR *convert_VkPipelineExecutableInternalRepresentationKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableInternalRepresentationKHR32 *in, uint32_t count) { VkPipelineExecutableInternalRepresentationKHR *out; unsigned int i; @@ -38064,7 +38053,18 @@ static inline VkPipelineExecutableInternalRepresentationKHR *convert_VkPipelineE return out; }

-static inline void convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out, uint32_t count) +static void convert_VkPipelineExecutableInternalRepresentationKHR_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out) +{ + if (!in) return; + + memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); + memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); + out->isText = in->isText; + out->dataSize = in->dataSize; + out->pData = PtrToUlong(in->pData); +} + +static void convert_VkPipelineExecutableInternalRepresentationKHR_array_host_to_win32(const VkPipelineExecutableInternalRepresentationKHR *in, VkPipelineExecutableInternalRepresentationKHR32 *out, uint32_t count) { unsigned int i;

@@ -38076,7 +38076,7 @@ static inline void convert_VkPipelineExecutableInternalRepresentationKHR_array_h } }

-static inline void convert_VkPipelineInfoKHR_win32_to_host(const VkPipelineInfoKHR32 *in, VkPipelineInfoKHR *out) +static void convert_VkPipelineInfoKHR_win32_to_host(const VkPipelineInfoKHR32 *in, VkPipelineInfoKHR *out) { if (!in) return;

@@ -38087,7 +38087,7 @@ static inline void convert_VkPipelineInfoKHR_win32_to_host(const VkPipelineInfoK FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPipelineExecutablePropertiesKHR_win32_to_host(const VkPipelineExecutablePropertiesKHR32 *in, VkPipelineExecutablePropertiesKHR *out) +static void convert_VkPipelineExecutablePropertiesKHR_win32_to_host(const VkPipelineExecutablePropertiesKHR32 *in, VkPipelineExecutablePropertiesKHR *out) { if (!in) return;

@@ -38097,17 +38097,7 @@ static inline void convert_VkPipelineExecutablePropertiesKHR_win32_to_host(const FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPipelineExecutablePropertiesKHR_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out) -{ - if (!in) return; - - out->stages = in->stages; - memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); - memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); - out->subgroupSize = in->subgroupSize; -} - -static inline VkPipelineExecutablePropertiesKHR *convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutablePropertiesKHR32 *in, uint32_t count) +static VkPipelineExecutablePropertiesKHR *convert_VkPipelineExecutablePropertiesKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutablePropertiesKHR32 *in, uint32_t count) { VkPipelineExecutablePropertiesKHR *out; unsigned int i; @@ -38123,7 +38113,17 @@ static inline VkPipelineExecutablePropertiesKHR *convert_VkPipelineExecutablePro return out; }

-static inline void convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out, uint32_t count) +static void convert_VkPipelineExecutablePropertiesKHR_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out) +{ + if (!in) return; + + out->stages = in->stages; + memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); + memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); + out->subgroupSize = in->subgroupSize; +} + +static void convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32(const VkPipelineExecutablePropertiesKHR *in, VkPipelineExecutablePropertiesKHR32 *out, uint32_t count) { unsigned int i;

@@ -38135,21 +38135,7 @@ static inline void convert_VkPipelineExecutablePropertiesKHR_array_host_to_win32 } }

-static inline void convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(const VkPipelineExecutableStatisticValueKHR *in, VkPipelineExecutableStatisticValueKHR32 *out, VkFlags selector) -{ - if (!in) return; - - if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR) - out->b32 = in->b32; - if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR) - out->i64 = in->i64; - if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR) - out->u64 = in->u64; - if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR) - out->f64 = in->f64; -} - -static inline void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const VkPipelineExecutableStatisticKHR32 *in, VkPipelineExecutableStatisticKHR *out) +static void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const VkPipelineExecutableStatisticKHR32 *in, VkPipelineExecutableStatisticKHR *out) { if (!in) return;

@@ -38159,17 +38145,7 @@ static inline void convert_VkPipelineExecutableStatisticKHR_win32_to_host(const FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPipelineExecutableStatisticKHR_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out) -{ - if (!in) return; - - memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); - memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); - out->format = in->format; - convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(&in->value, &out->value, in->format); -} - -static inline VkPipelineExecutableStatisticKHR *convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableStatisticKHR32 *in, uint32_t count) +static VkPipelineExecutableStatisticKHR *convert_VkPipelineExecutableStatisticKHR_array_win32_to_host(struct conversion_context *ctx, const VkPipelineExecutableStatisticKHR32 *in, uint32_t count) { VkPipelineExecutableStatisticKHR *out; unsigned int i; @@ -38185,7 +38161,31 @@ static inline VkPipelineExecutableStatisticKHR *convert_VkPipelineExecutableStat return out; }

-static inline void convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out, uint32_t count) +static void convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(const VkPipelineExecutableStatisticValueKHR *in, VkPipelineExecutableStatisticValueKHR32 *out, VkFlags selector) +{ + if (!in) return; + + if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR) + out->b32 = in->b32; + if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR) + out->i64 = in->i64; + if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR) + out->u64 = in->u64; + if (selector == VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR) + out->f64 = in->f64; +} + +static void convert_VkPipelineExecutableStatisticKHR_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out) +{ + if (!in) return; + + memcpy(out->name, in->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); + memcpy(out->description, in->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)); + out->format = in->format; + convert_VkPipelineExecutableStatisticValueKHR_host_to_win32(&in->value, &out->value, in->format); +} + +static void convert_VkPipelineExecutableStatisticKHR_array_host_to_win32(const VkPipelineExecutableStatisticKHR *in, VkPipelineExecutableStatisticKHR32 *out, uint32_t count) { unsigned int i;

@@ -38197,7 +38197,7 @@ static inline void convert_VkPipelineExecutableStatisticKHR_array_host_to_win32( } }

-static inline void convert_VkPipelineIndirectDeviceAddressInfoNV_win32_to_host(const VkPipelineIndirectDeviceAddressInfoNV32 *in, VkPipelineIndirectDeviceAddressInfoNV *out) +static void convert_VkPipelineIndirectDeviceAddressInfoNV_win32_to_host(const VkPipelineIndirectDeviceAddressInfoNV32 *in, VkPipelineIndirectDeviceAddressInfoNV *out) { if (!in) return;

@@ -38209,7 +38209,7 @@ static inline void convert_VkPipelineIndirectDeviceAddressInfoNV_win32_to_host(c FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoEXT32 *in, VkPipelineInfoEXT *out) +static void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoEXT32 *in, VkPipelineInfoEXT *out) { if (!in) return;

@@ -38220,7 +38220,7 @@ static inline void convert_VkPipelineInfoEXT_win32_to_host(const VkPipelineInfoE FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCheckpointData2NV_win32_to_host(const VkCheckpointData2NV32 *in, VkCheckpointData2NV *out) +static void convert_VkCheckpointData2NV_win32_to_host(const VkCheckpointData2NV32 *in, VkCheckpointData2NV *out) { if (!in) return;

@@ -38230,15 +38230,7 @@ static inline void convert_VkCheckpointData2NV_win32_to_host(const VkCheckpointD FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCheckpointData2NV_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out) -{ - if (!in) return; - - out->stage = in->stage; - out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker); -} - -static inline VkCheckpointData2NV *convert_VkCheckpointData2NV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointData2NV32 *in, uint32_t count) +static VkCheckpointData2NV *convert_VkCheckpointData2NV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointData2NV32 *in, uint32_t count) { VkCheckpointData2NV *out; unsigned int i; @@ -38254,7 +38246,15 @@ static inline VkCheckpointData2NV *convert_VkCheckpointData2NV_array_win32_to_ho return out; }

-static inline void convert_VkCheckpointData2NV_array_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out, uint32_t count) +static void convert_VkCheckpointData2NV_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out) +{ + if (!in) return; + + out->stage = in->stage; + out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker); +} + +static void convert_VkCheckpointData2NV_array_host_to_win32(const VkCheckpointData2NV *in, VkCheckpointData2NV32 *out, uint32_t count) { unsigned int i;

@@ -38266,7 +38266,7 @@ static inline void convert_VkCheckpointData2NV_array_host_to_win32(const VkCheck } }

-static inline void convert_VkCheckpointDataNV_win32_to_host(const VkCheckpointDataNV32 *in, VkCheckpointDataNV *out) +static void convert_VkCheckpointDataNV_win32_to_host(const VkCheckpointDataNV32 *in, VkCheckpointDataNV *out) { if (!in) return;

@@ -38276,15 +38276,7 @@ static inline void convert_VkCheckpointDataNV_win32_to_host(const VkCheckpointDa FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCheckpointDataNV_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out) -{ - if (!in) return; - - out->stage = in->stage; - out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker); -} - -static inline VkCheckpointDataNV *convert_VkCheckpointDataNV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointDataNV32 *in, uint32_t count) +static VkCheckpointDataNV *convert_VkCheckpointDataNV_array_win32_to_host(struct conversion_context *ctx, const VkCheckpointDataNV32 *in, uint32_t count) { VkCheckpointDataNV *out; unsigned int i; @@ -38300,7 +38292,15 @@ static inline VkCheckpointDataNV *convert_VkCheckpointDataNV_array_win32_to_host return out; }

-static inline void convert_VkCheckpointDataNV_array_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out, uint32_t count) +static void convert_VkCheckpointDataNV_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out) +{ + if (!in) return; + + out->stage = in->stage; + out->pCheckpointMarker = PtrToUlong(in->pCheckpointMarker); +} + +static void convert_VkCheckpointDataNV_array_host_to_win32(const VkCheckpointDataNV *in, VkCheckpointDataNV32 *out, uint32_t count) { unsigned int i;

@@ -38312,7 +38312,7 @@ static inline void convert_VkCheckpointDataNV_array_host_to_win32(const VkCheckp } }

-static inline void convert_VkRenderingAreaInfo_win32_to_host(const VkRenderingAreaInfo32 *in, VkRenderingAreaInfo *out) +static void convert_VkRenderingAreaInfo_win32_to_host(const VkRenderingAreaInfo32 *in, VkRenderingAreaInfo *out) { if (!in) return;

@@ -38327,7 +38327,7 @@ static inline void convert_VkRenderingAreaInfo_win32_to_host(const VkRenderingAr FIXME("Unexpected pNext\n"); }

-static inline void convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host(const VkSamplerCaptureDescriptorDataInfoEXT32 *in, VkSamplerCaptureDescriptorDataInfoEXT *out) +static void convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host(const VkSamplerCaptureDescriptorDataInfoEXT32 *in, VkSamplerCaptureDescriptorDataInfoEXT *out) { if (!in) return;

@@ -38338,7 +38338,7 @@ static inline void convert_VkSamplerCaptureDescriptorDataInfoEXT_win32_to_host(c FIXME("Unexpected pNext\n"); }

-static inline void convert_VkShaderModuleIdentifierEXT_win32_to_host(const VkShaderModuleIdentifierEXT32 *in, VkShaderModuleIdentifierEXT *out) +static void convert_VkShaderModuleIdentifierEXT_win32_to_host(const VkShaderModuleIdentifierEXT32 *in, VkShaderModuleIdentifierEXT *out) { if (!in) return;

@@ -38348,7 +38348,7 @@ static inline void convert_VkShaderModuleIdentifierEXT_win32_to_host(const VkSha FIXME("Unexpected pNext\n"); }

-static inline void convert_VkShaderModuleIdentifierEXT_host_to_win32(const VkShaderModuleIdentifierEXT *in, VkShaderModuleIdentifierEXT32 *out) +static void convert_VkShaderModuleIdentifierEXT_host_to_win32(const VkShaderModuleIdentifierEXT *in, VkShaderModuleIdentifierEXT32 *out) { if (!in) return;

@@ -38356,7 +38356,7 @@ static inline void convert_VkShaderModuleIdentifierEXT_host_to_win32(const VkSha memcpy(out->identifier, in->identifier, VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t)); }

-static inline void convert_VkTensorMemoryRequirementsInfoARM_win32_to_host(const VkTensorMemoryRequirementsInfoARM32 *in, VkTensorMemoryRequirementsInfoARM *out) +static void convert_VkTensorMemoryRequirementsInfoARM_win32_to_host(const VkTensorMemoryRequirementsInfoARM32 *in, VkTensorMemoryRequirementsInfoARM *out) { if (!in) return;

@@ -38367,7 +38367,7 @@ static inline void convert_VkTensorMemoryRequirementsInfoARM_win32_to_host(const FIXME("Unexpected pNext\n"); }

-static inline void convert_VkTensorCaptureDescriptorDataInfoARM_win32_to_host(const VkTensorCaptureDescriptorDataInfoARM32 *in, VkTensorCaptureDescriptorDataInfoARM *out) +static void convert_VkTensorCaptureDescriptorDataInfoARM_win32_to_host(const VkTensorCaptureDescriptorDataInfoARM32 *in, VkTensorCaptureDescriptorDataInfoARM *out) { if (!in) return;

@@ -38378,7 +38378,7 @@ static inline void convert_VkTensorCaptureDescriptorDataInfoARM_win32_to_host(co FIXME("Unexpected pNext\n"); }

-static inline void convert_VkTensorViewCaptureDescriptorDataInfoARM_win32_to_host(const VkTensorViewCaptureDescriptorDataInfoARM32 *in, VkTensorViewCaptureDescriptorDataInfoARM *out) +static void convert_VkTensorViewCaptureDescriptorDataInfoARM_win32_to_host(const VkTensorViewCaptureDescriptorDataInfoARM32 *in, VkTensorViewCaptureDescriptorDataInfoARM *out) { if (!in) return;

@@ -38389,7 +38389,7 @@ static inline void convert_VkTensorViewCaptureDescriptorDataInfoARM_win32_to_hos FIXME("Unexpected pNext\n"); }

-static inline void convert_VkVideoSessionMemoryRequirementsKHR_win32_to_host(const VkVideoSessionMemoryRequirementsKHR32 *in, VkVideoSessionMemoryRequirementsKHR *out) +static void convert_VkVideoSessionMemoryRequirementsKHR_win32_to_host(const VkVideoSessionMemoryRequirementsKHR32 *in, VkVideoSessionMemoryRequirementsKHR *out) { if (!in) return;

@@ -38399,15 +38399,7 @@ static inline void convert_VkVideoSessionMemoryRequirementsKHR_win32_to_host(con FIXME("Unexpected pNext\n"); }

-static inline void convert_VkVideoSessionMemoryRequirementsKHR_host_to_win32(const VkVideoSessionMemoryRequirementsKHR *in, VkVideoSessionMemoryRequirementsKHR32 *out) -{ - if (!in) return; - - out->memoryBindIndex = in->memoryBindIndex; - convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements); -} - -static inline VkVideoSessionMemoryRequirementsKHR *convert_VkVideoSessionMemoryRequirementsKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoSessionMemoryRequirementsKHR32 *in, uint32_t count) +static VkVideoSessionMemoryRequirementsKHR *convert_VkVideoSessionMemoryRequirementsKHR_array_win32_to_host(struct conversion_context *ctx, const VkVideoSessionMemoryRequirementsKHR32 *in, uint32_t count) { VkVideoSessionMemoryRequirementsKHR *out; unsigned int i; @@ -38423,7 +38415,15 @@ static inline VkVideoSessionMemoryRequirementsKHR *convert_VkVideoSessionMemoryR return out; }

-static inline void convert_VkVideoSessionMemoryRequirementsKHR_array_host_to_win32(const VkVideoSessionMemoryRequirementsKHR *in, VkVideoSessionMemoryRequirementsKHR32 *out, uint32_t count) +static void convert_VkVideoSessionMemoryRequirementsKHR_host_to_win32(const VkVideoSessionMemoryRequirementsKHR *in, VkVideoSessionMemoryRequirementsKHR32 *out) +{ + if (!in) return; + + out->memoryBindIndex = in->memoryBindIndex; + convert_VkMemoryRequirements_host_to_win32(&in->memoryRequirements, &out->memoryRequirements); +} + +static void convert_VkVideoSessionMemoryRequirementsKHR_array_host_to_win32(const VkVideoSessionMemoryRequirementsKHR *in, VkVideoSessionMemoryRequirementsKHR32 *out, uint32_t count) { unsigned int i;

@@ -38435,7 +38435,7 @@ static inline void convert_VkVideoSessionMemoryRequirementsKHR_array_host_to_win } }

-static inline void convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(const VkInitializePerformanceApiInfoINTEL32 *in, VkInitializePerformanceApiInfoINTEL *out) +static void convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(const VkInitializePerformanceApiInfoINTEL32 *in, VkInitializePerformanceApiInfoINTEL *out) { if (!in) return;

@@ -38446,7 +38446,7 @@ static inline void convert_VkInitializePerformanceApiInfoINTEL_win32_to_host(con FIXME("Unexpected pNext\n"); }

-static inline void convert_VkLatencySleepInfoNV_win32_to_host(const VkLatencySleepInfoNV32 *in, VkLatencySleepInfoNV *out) +static void convert_VkLatencySleepInfoNV_win32_to_host(const VkLatencySleepInfoNV32 *in, VkLatencySleepInfoNV *out) { if (!in) return;

@@ -38459,7 +38459,7 @@ static inline void convert_VkLatencySleepInfoNV_win32_to_host(const VkLatencySle }

#ifdef _WIN64 -static inline void convert_VkMemoryMapInfo_win64_to_host(const VkMemoryMapInfo *in, VkMemoryMapInfo *out) +static void convert_VkMemoryMapInfo_win64_to_host(const VkMemoryMapInfo *in, VkMemoryMapInfo *out) { if (!in) return;

@@ -38472,7 +38472,7 @@ static inline void convert_VkMemoryMapInfo_win64_to_host(const VkMemoryMapInfo * } #endif /* _WIN64 */

-static inline void convert_VkMemoryMapInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryMapInfo32 *in, VkMemoryMapInfo *out) +static void convert_VkMemoryMapInfo_win32_to_host(struct conversion_context *ctx, const VkMemoryMapInfo32 *in, VkMemoryMapInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -38508,7 +38508,7 @@ static inline void convert_VkMemoryMapInfo_win32_to_host(struct conversion_conte } }

-static inline void convert_VkMemoryMapInfo_win32_to_unwrapped_host(struct conversion_context *ctx, const VkMemoryMapInfo32 *in, VkMemoryMapInfo *out) +static void convert_VkMemoryMapInfo_win32_to_unwrapped_host(struct conversion_context *ctx, const VkMemoryMapInfo32 *in, VkMemoryMapInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -38545,7 +38545,7 @@ static inline void convert_VkMemoryMapInfo_win32_to_unwrapped_host(struct conver }

#ifdef _WIN64 -static inline void convert_VkSparseMemoryBind_win64_to_host(const VkSparseMemoryBind *in, VkSparseMemoryBind *out) +static void convert_VkSparseMemoryBind_win64_to_host(const VkSparseMemoryBind *in, VkSparseMemoryBind *out) { if (!in) return;

@@ -38557,19 +38557,8 @@ static inline void convert_VkSparseMemoryBind_win64_to_host(const VkSparseMemory } #endif /* _WIN64 */

-static inline void convert_VkSparseMemoryBind_win32_to_host(const VkSparseMemoryBind32 *in, VkSparseMemoryBind *out) -{ - if (!in) return; - - out->resourceOffset = in->resourceOffset; - out->size = in->size; - out->memory = in->memory ? vulkan_device_memory_from_handle(in->memory)->host.device_memory : 0; - out->memoryOffset = in->memoryOffset; - out->flags = in->flags; -} - #ifdef _WIN64 -static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseMemoryBind *in, uint32_t count) +static const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseMemoryBind *in, uint32_t count) { VkSparseMemoryBind *out; unsigned int i; @@ -38586,9 +38575,21 @@ static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win64_t } #endif /* _WIN64 */

-static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseMemoryBind32 *in, uint32_t count) +#ifdef _WIN64 +static void convert_VkSparseBufferMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, VkSparseBufferMemoryBindInfo *out) { - VkSparseMemoryBind *out; + if (!in) return; + + out->buffer = in->buffer; + out->bindCount = in->bindCount; + out->pBinds = convert_VkSparseMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount); +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, uint32_t count) +{ + VkSparseBufferMemoryBindInfo *out; unsigned int i;

if (!in || !count) return NULL; @@ -38596,36 +38597,28 @@ static inline const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win32_t out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkSparseMemoryBind_win32_to_host(&in[i], &out[i]); + convert_VkSparseBufferMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]); }

return out; } +#endif /* _WIN64 */

#ifdef _WIN64 -static inline void convert_VkSparseBufferMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, VkSparseBufferMemoryBindInfo *out) +static void convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, VkSparseImageOpaqueMemoryBindInfo *out) { if (!in) return;

- out->buffer = in->buffer; + out->image = in->image; out->bindCount = in->bindCount; out->pBinds = convert_VkSparseMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount); } #endif /* _WIN64 */

-static inline void convert_VkSparseBufferMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, VkSparseBufferMemoryBindInfo *out) -{ - if (!in) return; - - out->buffer = in->buffer; - out->bindCount = in->bindCount; - out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount); -} - #ifdef _WIN64 -static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo *in, uint32_t count) +static const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, uint32_t count) { - VkSparseBufferMemoryBindInfo *out; + VkSparseImageOpaqueMemoryBindInfo *out; unsigned int i;

if (!in || !count) return NULL; @@ -38633,16 +38626,31 @@ static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBi out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkSparseBufferMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]); + convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]); }

return out; } #endif /* _WIN64 */

-static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, uint32_t count) +#ifdef _WIN64 +static void convert_VkSparseImageMemoryBind_win64_to_host(const VkSparseImageMemoryBind *in, VkSparseImageMemoryBind *out) { - VkSparseBufferMemoryBindInfo *out; + if (!in) return; + + out->subresource = in->subresource; + out->offset = in->offset; + out->extent = in->extent; + out->memory = in->memory ? vulkan_device_memory_from_handle(in->memory)->host.device_memory : 0; + out->memoryOffset = in->memoryOffset; + out->flags = in->flags; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind *in, uint32_t count) +{ + VkSparseImageMemoryBind *out; unsigned int i;

if (!in || !count) return NULL; @@ -38650,36 +38658,66 @@ static inline const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBi out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkSparseBufferMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]); + convert_VkSparseImageMemoryBind_win64_to_host(&in[i], &out[i]); }

return out; } +#endif /* _WIN64 */

#ifdef _WIN64 -static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, VkSparseImageOpaqueMemoryBindInfo *out) +static void convert_VkSparseImageMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, VkSparseImageMemoryBindInfo *out) { if (!in) return;

out->image = in->image; out->bindCount = in->bindCount; - out->pBinds = convert_VkSparseMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount); + out->pBinds = convert_VkSparseImageMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount); +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, uint32_t count) +{ + VkSparseImageMemoryBindInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkSparseImageMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]); + } + + return out; } #endif /* _WIN64 */

-static inline void convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, VkSparseImageOpaqueMemoryBindInfo *out) +#ifdef _WIN64 +static void convert_VkBindSparseInfo_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, VkBindSparseInfo *out) { if (!in) return;

- out->image = in->image; - out->bindCount = in->bindCount; - out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount); + out->sType = in->sType; + out->pNext = in->pNext; + out->waitSemaphoreCount = in->waitSemaphoreCount; + out->pWaitSemaphores = in->pWaitSemaphores; + out->bufferBindCount = in->bufferBindCount; + out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(ctx, in->pBufferBinds, in->bufferBindCount); + out->imageOpaqueBindCount = in->imageOpaqueBindCount; + out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(ctx, in->pImageOpaqueBinds, in->imageOpaqueBindCount); + out->imageBindCount = in->imageBindCount; + out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win64_to_host(ctx, in->pImageBinds, in->imageBindCount); + out->signalSemaphoreCount = in->signalSemaphoreCount; + out->pSignalSemaphores = in->pSignalSemaphores; } +#endif /* _WIN64 */

#ifdef _WIN64 -static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo *in, uint32_t count) +static const VkBindSparseInfo *convert_VkBindSparseInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, uint32_t count) { - VkSparseImageOpaqueMemoryBindInfo *out; + VkBindSparseInfo *out; unsigned int i;

if (!in || !count) return NULL; @@ -38687,16 +38725,27 @@ static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaq out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkSparseImageOpaqueMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]); + convert_VkBindSparseInfo_win64_to_host(ctx, &in[i], &out[i]); }

return out; } #endif /* _WIN64 */

-static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, uint32_t count) +static void convert_VkSparseMemoryBind_win32_to_host(const VkSparseMemoryBind32 *in, VkSparseMemoryBind *out) { - VkSparseImageOpaqueMemoryBindInfo *out; + if (!in) return; + + out->resourceOffset = in->resourceOffset; + out->size = in->size; + out->memory = in->memory ? vulkan_device_memory_from_handle(in->memory)->host.device_memory : 0; + out->memoryOffset = in->memoryOffset; + out->flags = in->flags; +} + +static const VkSparseMemoryBind *convert_VkSparseMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseMemoryBind32 *in, uint32_t count) +{ + VkSparseMemoryBind *out; unsigned int i;

if (!in || !count) return NULL; @@ -38704,42 +38753,49 @@ static inline const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaq out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]); + convert_VkSparseMemoryBind_win32_to_host(&in[i], &out[i]); }

return out; }

-#ifdef _WIN64 -static inline void convert_VkSparseImageMemoryBind_win64_to_host(const VkSparseImageMemoryBind *in, VkSparseImageMemoryBind *out) +static void convert_VkSparseBufferMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, VkSparseBufferMemoryBindInfo *out) { if (!in) return;

- out->subresource = in->subresource; - out->offset = in->offset; - out->extent = in->extent; - out->memory = in->memory ? vulkan_device_memory_from_handle(in->memory)->host.device_memory : 0; - out->memoryOffset = in->memoryOffset; - out->flags = in->flags; + out->buffer = in->buffer; + out->bindCount = in->bindCount; + out->pBinds = convert_VkSparseMemoryBind_array_win32_to_host(ctx, (const VkSparseMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount); +} + +static const VkSparseBufferMemoryBindInfo *convert_VkSparseBufferMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseBufferMemoryBindInfo32 *in, uint32_t count) +{ + VkSparseBufferMemoryBindInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkSparseBufferMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; } -#endif /* _WIN64 */

-static inline void convert_VkSparseImageMemoryBind_win32_to_host(const VkSparseImageMemoryBind32 *in, VkSparseImageMemoryBind *out) +static void convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, VkSparseImageOpaqueMemoryBindInfo *out) { if (!in) return;

-#ifdef _WIN64 -static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind *in, uint32_t count) +static const VkSparseImageOpaqueMemoryBindInfo *convert_VkSparseImageOpaqueMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageOpaqueMemoryBindInfo32 *in, uint32_t count) { - VkSparseImageMemoryBind *out; + VkSparseImageOpaqueMemoryBindInfo *out; unsigned int i;

if (!in || !count) return NULL; @@ -38747,14 +38803,25 @@ static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_arr out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkSparseImageMemoryBind_win64_to_host(&in[i], &out[i]); + convert_VkSparseImageOpaqueMemoryBindInfo_win32_to_host(ctx, &in[i], &out[i]); }

return out; } -#endif /* _WIN64 */

-static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind32 *in, uint32_t count) +static void convert_VkSparseImageMemoryBind_win32_to_host(const VkSparseImageMemoryBind32 *in, VkSparseImageMemoryBind *out) +{ + if (!in) return; + + out->subresource = in->subresource; + out->offset = in->offset; + out->extent = in->extent; + out->memory = in->memory ? vulkan_device_memory_from_handle(in->memory)->host.device_memory : 0; + out->memoryOffset = in->memoryOffset; + out->flags = in->flags; +} + +static const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBind32 *in, uint32_t count) { VkSparseImageMemoryBind *out; unsigned int i; @@ -38770,18 +38837,7 @@ static inline const VkSparseImageMemoryBind *convert_VkSparseImageMemoryBind_arr return out; }

-#ifdef _WIN64 -static inline void convert_VkSparseImageMemoryBindInfo_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, VkSparseImageMemoryBindInfo *out) -{ - if (!in) return; - - out->image = in->image; - out->bindCount = in->bindCount; - out->pBinds = convert_VkSparseImageMemoryBind_array_win64_to_host(ctx, in->pBinds, in->bindCount); -} -#endif /* _WIN64 */ - -static inline void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, VkSparseImageMemoryBindInfo *out) +static void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, VkSparseImageMemoryBindInfo *out) { if (!in) return;

@@ -38790,25 +38846,7 @@ static inline void convert_VkSparseImageMemoryBindInfo_win32_to_host(struct conv out->pBinds = convert_VkSparseImageMemoryBind_array_win32_to_host(ctx, (const VkSparseImageMemoryBind32 *)UlongToPtr(in->pBinds), in->bindCount); }

-#ifdef _WIN64 -static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win64_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo *in, uint32_t count) -{ - VkSparseImageMemoryBindInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkSparseImageMemoryBindInfo_win64_to_host(ctx, &in[i], &out[i]); - } - - return out; -} -#endif /* _WIN64 */ - -static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, uint32_t count) +static const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBindInfo_array_win32_to_host(struct conversion_context *ctx, const VkSparseImageMemoryBindInfo32 *in, uint32_t count) { VkSparseImageMemoryBindInfo *out; unsigned int i; @@ -38824,27 +38862,7 @@ static inline const VkSparseImageMemoryBindInfo *convert_VkSparseImageMemoryBind return out; }

-#ifdef _WIN64 -static inline void convert_VkBindSparseInfo_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, VkBindSparseInfo *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = in->pNext; - out->waitSemaphoreCount = in->waitSemaphoreCount; - out->pWaitSemaphores = in->pWaitSemaphores; - out->bufferBindCount = in->bufferBindCount; - out->pBufferBinds = convert_VkSparseBufferMemoryBindInfo_array_win64_to_host(ctx, in->pBufferBinds, in->bufferBindCount); - out->imageOpaqueBindCount = in->imageOpaqueBindCount; - out->pImageOpaqueBinds = convert_VkSparseImageOpaqueMemoryBindInfo_array_win64_to_host(ctx, in->pImageOpaqueBinds, in->imageOpaqueBindCount); - out->imageBindCount = in->imageBindCount; - out->pImageBinds = convert_VkSparseImageMemoryBindInfo_array_win64_to_host(ctx, in->pImageBinds, in->imageBindCount); - out->signalSemaphoreCount = in->signalSemaphoreCount; - out->pSignalSemaphores = in->pSignalSemaphores; -} -#endif /* _WIN64 */ - -static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, VkBindSparseInfo *out) +static void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, VkBindSparseInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -38932,25 +38950,7 @@ static inline void convert_VkBindSparseInfo_win32_to_host(struct conversion_cont } }

-#ifdef _WIN64 -static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win64_to_host(struct conversion_context *ctx, const VkBindSparseInfo *in, uint32_t count) -{ - VkBindSparseInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkBindSparseInfo_win64_to_host(ctx, &in[i], &out[i]); - } - - return out; -} -#endif /* _WIN64 */ - -static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, uint32_t count) +static const VkBindSparseInfo *convert_VkBindSparseInfo_array_win32_to_host(struct conversion_context *ctx, const VkBindSparseInfo32 *in, uint32_t count) { VkBindSparseInfo *out; unsigned int i; @@ -38966,7 +38966,7 @@ static inline const VkBindSparseInfo *convert_VkBindSparseInfo_array_win32_to_ho return out; }

-static inline void convert_VkOutOfBandQueueTypeInfoNV_win32_to_host(const VkOutOfBandQueueTypeInfoNV32 *in, VkOutOfBandQueueTypeInfoNV *out) +static void convert_VkOutOfBandQueueTypeInfoNV_win32_to_host(const VkOutOfBandQueueTypeInfoNV32 *in, VkOutOfBandQueueTypeInfoNV *out) { if (!in) return;

@@ -38977,7 +38977,7 @@ static inline void convert_VkOutOfBandQueueTypeInfoNV_win32_to_host(const VkOutO FIXME("Unexpected pNext\n"); }

-static inline void convert_VkPresentRegionKHR_win32_to_host(const VkPresentRegionKHR32 *in, VkPresentRegionKHR *out) +static void convert_VkPresentRegionKHR_win32_to_host(const VkPresentRegionKHR32 *in, VkPresentRegionKHR *out) { if (!in) return;

@@ -38985,7 +38985,7 @@ static inline void convert_VkPresentRegionKHR_win32_to_host(const VkPresentRegio out->pRectangles = UlongToPtr(in->pRectangles); }

-static inline const VkPresentRegionKHR *convert_VkPresentRegionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPresentRegionKHR32 *in, uint32_t count) +static const VkPresentRegionKHR *convert_VkPresentRegionKHR_array_win32_to_host(struct conversion_context *ctx, const VkPresentRegionKHR32 *in, uint32_t count) { VkPresentRegionKHR *out; unsigned int i; @@ -39001,7 +39001,7 @@ static inline const VkPresentRegionKHR *convert_VkPresentRegionKHR_array_win32_t return out; }

-static inline void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPresentInfoKHR32 *in, VkPresentInfoKHR *out) +static void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conversion_context *ctx, const VkPresentInfoKHR32 *in, VkPresentInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -39133,7 +39133,7 @@ static inline void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conve }

#ifdef _WIN64 -static inline void convert_VkSubmitInfo_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, VkSubmitInfo *out) +static void convert_VkSubmitInfo_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, VkSubmitInfo *out) { if (!in) return;

@@ -39149,7 +39149,25 @@ static inline void convert_VkSubmitInfo_win64_to_host(struct conversion_context } #endif /* _WIN64 */

-static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, VkSubmitInfo *out) +#ifdef _WIN64 +static const VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, uint32_t count) +{ + VkSubmitInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkSubmitInfo_win64_to_host(ctx, &in[i], &out[i]); + } + + return out; +} +#endif /* _WIN64 */ + +static void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, VkSubmitInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -39271,8 +39289,7 @@ static inline void convert_VkSubmitInfo_win32_to_host(struct conversion_context } }

-#ifdef _WIN64 -static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo *in, uint32_t count) +static const VkSubmitInfo *convert_VkSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, uint32_t count) { VkSubmitInfo *out; unsigned int i; @@ -39282,16 +39299,28 @@ static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win64_to_host(struc out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkSubmitInfo_win64_to_host(ctx, &in[i], &out[i]); + convert_VkSubmitInfo_win32_to_host(ctx, &in[i], &out[i]); }

return out; } + +#ifdef _WIN64 +static void convert_VkCommandBufferSubmitInfo_win64_to_host(const VkCommandBufferSubmitInfo *in, VkCommandBufferSubmitInfo *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->host.command_buffer; + out->deviceMask = in->deviceMask; +} #endif /* _WIN64 */

-static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo32 *in, uint32_t count) +#ifdef _WIN64 +static const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo *in, uint32_t count) { - VkSubmitInfo *out; + VkCommandBufferSubmitInfo *out; unsigned int i;

if (!in || !count) return NULL; @@ -39299,13 +39328,49 @@ static inline const VkSubmitInfo *convert_VkSubmitInfo_array_win32_to_host(struc out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkSubmitInfo_win32_to_host(ctx, &in[i], &out[i]); + convert_VkCommandBufferSubmitInfo_win64_to_host(&in[i], &out[i]); + } + + return out; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static void convert_VkSubmitInfo2_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, VkSubmitInfo2 *out) +{ + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->flags = in->flags; + out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount; + out->pWaitSemaphoreInfos = in->pWaitSemaphoreInfos; + out->commandBufferInfoCount = in->commandBufferInfoCount; + out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win64_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount); + out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount; + out->pSignalSemaphoreInfos = in->pSignalSemaphoreInfos; +} +#endif /* _WIN64 */ + +#ifdef _WIN64 +static const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, uint32_t count) +{ + VkSubmitInfo2 *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_VkSubmitInfo2_win64_to_host(ctx, &in[i], &out[i]); }

return out; } +#endif /* _WIN64 */

-static inline void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphoreSubmitInfo32 *in, VkSemaphoreSubmitInfo *out) +static void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphoreSubmitInfo32 *in, VkSemaphoreSubmitInfo *out) { if (!in) return;

@@ -39319,7 +39384,7 @@ static inline void convert_VkSemaphoreSubmitInfo_win32_to_host(const VkSemaphore FIXME("Unexpected pNext\n"); }

-static inline const VkSemaphoreSubmitInfo *convert_VkSemaphoreSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSemaphoreSubmitInfo32 *in, uint32_t count) +static const VkSemaphoreSubmitInfo *convert_VkSemaphoreSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkSemaphoreSubmitInfo32 *in, uint32_t count) { VkSemaphoreSubmitInfo *out; unsigned int i; @@ -39335,19 +39400,7 @@ static inline const VkSemaphoreSubmitInfo *convert_VkSemaphoreSubmitInfo_array_w return out; }

-#ifdef _WIN64 -static inline void convert_VkCommandBufferSubmitInfo_win64_to_host(const VkCommandBufferSubmitInfo *in, VkCommandBufferSubmitInfo *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = in->pNext; - out->commandBuffer = wine_cmd_buffer_from_handle(in->commandBuffer)->host.command_buffer; - out->deviceMask = in->deviceMask; -} -#endif /* _WIN64 */ - -static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, VkCommandBufferSubmitInfo *out) +static void convert_VkCommandBufferSubmitInfo_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, VkCommandBufferSubmitInfo *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -39382,25 +39435,7 @@ static inline void convert_VkCommandBufferSubmitInfo_win32_to_host(struct conver } }

-#ifdef _WIN64 -static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win64_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo *in, uint32_t count) -{ - VkCommandBufferSubmitInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkCommandBufferSubmitInfo_win64_to_host(&in[i], &out[i]); - } - - return out; -} -#endif /* _WIN64 */ - -static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, uint32_t count) +static const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo_array_win32_to_host(struct conversion_context *ctx, const VkCommandBufferSubmitInfo32 *in, uint32_t count) { VkCommandBufferSubmitInfo *out; unsigned int i; @@ -39416,24 +39451,7 @@ static inline const VkCommandBufferSubmitInfo *convert_VkCommandBufferSubmitInfo return out; }

-#ifdef _WIN64 -static inline void convert_VkSubmitInfo2_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, VkSubmitInfo2 *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = in->pNext; - out->flags = in->flags; - out->waitSemaphoreInfoCount = in->waitSemaphoreInfoCount; - out->pWaitSemaphoreInfos = in->pWaitSemaphoreInfos; - out->commandBufferInfoCount = in->commandBufferInfoCount; - out->pCommandBufferInfos = convert_VkCommandBufferSubmitInfo_array_win64_to_host(ctx, in->pCommandBufferInfos, in->commandBufferInfoCount); - out->signalSemaphoreInfoCount = in->signalSemaphoreInfoCount; - out->pSignalSemaphoreInfos = in->pSignalSemaphoreInfos; -} -#endif /* _WIN64 */ - -static inline void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, VkSubmitInfo2 *out) +static void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, VkSubmitInfo2 *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -39514,25 +39532,7 @@ static inline void convert_VkSubmitInfo2_win32_to_host(struct conversion_context } }

-#ifdef _WIN64 -static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win64_to_host(struct conversion_context *ctx, const VkSubmitInfo2 *in, uint32_t count) -{ - VkSubmitInfo2 *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_VkSubmitInfo2_win64_to_host(ctx, &in[i], &out[i]); - } - - return out; -} -#endif /* _WIN64 */ - -static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, uint32_t count) +static const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win32_to_host(struct conversion_context *ctx, const VkSubmitInfo232 *in, uint32_t count) { VkSubmitInfo2 *out; unsigned int i; @@ -39548,7 +39548,7 @@ static inline const VkSubmitInfo2 *convert_VkSubmitInfo2_array_win32_to_host(str return out; }

-static inline void convert_VkReleaseCapturedPipelineDataInfoKHR_win32_to_host(const VkReleaseCapturedPipelineDataInfoKHR32 *in, VkReleaseCapturedPipelineDataInfoKHR *out) +static void convert_VkReleaseCapturedPipelineDataInfoKHR_win32_to_host(const VkReleaseCapturedPipelineDataInfoKHR32 *in, VkReleaseCapturedPipelineDataInfoKHR *out) { if (!in) return;

@@ -39560,7 +39560,7 @@ static inline void convert_VkReleaseCapturedPipelineDataInfoKHR_win32_to_host(co }

#ifdef _WIN64 -static inline void convert_VkReleaseSwapchainImagesInfoKHR_win64_to_host(const VkReleaseSwapchainImagesInfoKHR *in, VkReleaseSwapchainImagesInfoKHR *out) +static void convert_VkReleaseSwapchainImagesInfoKHR_win64_to_host(const VkReleaseSwapchainImagesInfoKHR *in, VkReleaseSwapchainImagesInfoKHR *out) { if (!in) return;

@@ -39572,7 +39572,7 @@ static inline void convert_VkReleaseSwapchainImagesInfoKHR_win64_to_host(const V } #endif /* _WIN64 */

-static inline void convert_VkReleaseSwapchainImagesInfoKHR_win32_to_host(const VkReleaseSwapchainImagesInfoKHR32 *in, VkReleaseSwapchainImagesInfoKHR *out) +static void convert_VkReleaseSwapchainImagesInfoKHR_win32_to_host(const VkReleaseSwapchainImagesInfoKHR32 *in, VkReleaseSwapchainImagesInfoKHR *out) { if (!in) return;

@@ -39586,7 +39586,7 @@ static inline void convert_VkReleaseSwapchainImagesInfoKHR_win32_to_host(const V }

#ifdef _WIN64 -static inline void convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(const VkDebugUtilsObjectNameInfoEXT *in, VkDebugUtilsObjectNameInfoEXT *out) +static void convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(const VkDebugUtilsObjectNameInfoEXT *in, VkDebugUtilsObjectNameInfoEXT *out) { if (!in) return;

@@ -39598,7 +39598,7 @@ static inline void convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(const VkD } #endif /* _WIN64 */

-static inline void convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(const VkDebugUtilsObjectNameInfoEXT32 *in, VkDebugUtilsObjectNameInfoEXT *out) +static void convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(const VkDebugUtilsObjectNameInfoEXT32 *in, VkDebugUtilsObjectNameInfoEXT *out) { if (!in) return;

@@ -39612,7 +39612,7 @@ static inline void convert_VkDebugUtilsObjectNameInfoEXT_win32_to_host(const VkD }

#ifdef _WIN64 -static inline void convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(const VkDebugUtilsObjectTagInfoEXT *in, VkDebugUtilsObjectTagInfoEXT *out) +static void convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(const VkDebugUtilsObjectTagInfoEXT *in, VkDebugUtilsObjectTagInfoEXT *out) { if (!in) return;

@@ -39626,7 +39626,7 @@ static inline void convert_VkDebugUtilsObjectTagInfoEXT_win64_to_host(const VkDe } #endif /* _WIN64 */

-static inline void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDebugUtilsObjectTagInfoEXT32 *in, VkDebugUtilsObjectTagInfoEXT *out) +static void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDebugUtilsObjectTagInfoEXT32 *in, VkDebugUtilsObjectTagInfoEXT *out) { if (!in) return;

@@ -39642,7 +39642,7 @@ static inline void convert_VkDebugUtilsObjectTagInfoEXT_win32_to_host(const VkDe }

#ifdef _WIN64 -static inline const VkSwapchainKHR *convert_VkSwapchainKHR_array_win64_to_host(struct conversion_context *ctx, const VkSwapchainKHR *in, uint32_t count) +static const VkSwapchainKHR *convert_VkSwapchainKHR_array_win64_to_host(struct conversion_context *ctx, const VkSwapchainKHR *in, uint32_t count) { VkSwapchainKHR *out; unsigned int i; @@ -39659,7 +39659,7 @@ static inline const VkSwapchainKHR *convert_VkSwapchainKHR_array_win64_to_host(s } #endif /* _WIN64 */

-static inline const VkSwapchainKHR *convert_VkSwapchainKHR_array_win32_to_host(struct conversion_context *ctx, const VkSwapchainKHR *in, uint32_t count) +static const VkSwapchainKHR *convert_VkSwapchainKHR_array_win32_to_host(struct conversion_context *ctx, const VkSwapchainKHR *in, uint32_t count) { VkSwapchainKHR *out; unsigned int i; @@ -39675,7 +39675,7 @@ static inline const VkSwapchainKHR *convert_VkSwapchainKHR_array_win32_to_host(s return out; }

-static inline void convert_VkHdrMetadataEXT_win32_to_host(struct conversion_context *ctx, const VkHdrMetadataEXT32 *in, VkHdrMetadataEXT *out) +static void convert_VkHdrMetadataEXT_win32_to_host(struct conversion_context *ctx, const VkHdrMetadataEXT32 *in, VkHdrMetadataEXT *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -39716,7 +39716,7 @@ static inline void convert_VkHdrMetadataEXT_win32_to_host(struct conversion_cont } }

-static inline const VkHdrMetadataEXT *convert_VkHdrMetadataEXT_array_win32_to_host(struct conversion_context *ctx, const VkHdrMetadataEXT32 *in, uint32_t count) +static const VkHdrMetadataEXT *convert_VkHdrMetadataEXT_array_win32_to_host(struct conversion_context *ctx, const VkHdrMetadataEXT32 *in, uint32_t count) { VkHdrMetadataEXT *out; unsigned int i; @@ -39732,7 +39732,7 @@ static inline const VkHdrMetadataEXT *convert_VkHdrMetadataEXT_array_win32_to_ho return out; }

-static inline void convert_VkSetLatencyMarkerInfoNV_win32_to_host(const VkSetLatencyMarkerInfoNV32 *in, VkSetLatencyMarkerInfoNV *out) +static void convert_VkSetLatencyMarkerInfoNV_win32_to_host(const VkSetLatencyMarkerInfoNV32 *in, VkSetLatencyMarkerInfoNV *out) { if (!in) return;

@@ -39744,7 +39744,7 @@ static inline void convert_VkSetLatencyMarkerInfoNV_win32_to_host(const VkSetLat FIXME("Unexpected pNext\n"); }

-static inline void convert_VkLatencySleepModeInfoNV_win32_to_host(const VkLatencySleepModeInfoNV32 *in, VkLatencySleepModeInfoNV *out) +static void convert_VkLatencySleepModeInfoNV_win32_to_host(const VkLatencySleepModeInfoNV32 *in, VkLatencySleepModeInfoNV *out) { if (!in) return;

@@ -39757,7 +39757,7 @@ static inline void convert_VkLatencySleepModeInfoNV_win32_to_host(const VkLatenc FIXME("Unexpected pNext\n"); }

-static inline void convert_VkSemaphoreSignalInfo_win32_to_host(const VkSemaphoreSignalInfo32 *in, VkSemaphoreSignalInfo *out) +static void convert_VkSemaphoreSignalInfo_win32_to_host(const VkSemaphoreSignalInfo32 *in, VkSemaphoreSignalInfo *out) { if (!in) return;

@@ -39769,9 +39769,10 @@ static inline void convert_VkSemaphoreSignalInfo_win32_to_host(const VkSemaphore FIXME("Unexpected pNext\n"); }

-static inline const VkDebugUtilsLabelEXT *convert_VkDebugUtilsLabelEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsLabelEXT32 *in, uint32_t count) +#ifdef _WIN64 +static const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT *in, uint32_t count) { - VkDebugUtilsLabelEXT *out; + VkDebugUtilsObjectNameInfoEXT *out; unsigned int i;

if (!in || !count) return NULL; @@ -39779,16 +39780,36 @@ static inline const VkDebugUtilsLabelEXT *convert_VkDebugUtilsLabelEXT_array_win out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkDebugUtilsLabelEXT_win32_to_host(&in[i], &out[i]); + convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(&in[i], &out[i]); }

return out; } +#endif /* _WIN64 */

#ifdef _WIN64 -static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT *in, uint32_t count) +static void convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT *in, VkDebugUtilsMessengerCallbackDataEXT *out) { - VkDebugUtilsObjectNameInfoEXT *out; + if (!in) return; + + out->sType = in->sType; + out->pNext = in->pNext; + out->flags = in->flags; + out->pMessageIdName = in->pMessageIdName; + out->messageIdNumber = in->messageIdNumber; + out->pMessage = in->pMessage; + out->queueLabelCount = in->queueLabelCount; + out->pQueueLabels = in->pQueueLabels; + out->cmdBufLabelCount = in->cmdBufLabelCount; + out->pCmdBufLabels = in->pCmdBufLabels; + out->objectCount = in->objectCount; + out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(ctx, in->pObjects, in->objectCount); +} +#endif /* _WIN64 */ + +static const VkDebugUtilsLabelEXT *convert_VkDebugUtilsLabelEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsLabelEXT32 *in, uint32_t count) +{ + VkDebugUtilsLabelEXT *out; unsigned int i;

if (!in || !count) return NULL; @@ -39796,14 +39817,13 @@ static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNam out = conversion_context_alloc(ctx, count * sizeof(*out)); for (i = 0; i < count; i++) { - convert_VkDebugUtilsObjectNameInfoEXT_win64_to_host(&in[i], &out[i]); + convert_VkDebugUtilsLabelEXT_win32_to_host(&in[i], &out[i]); }

return out; } -#endif /* _WIN64 */

-static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT32 *in, uint32_t count) +static const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNameInfoEXT_array_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsObjectNameInfoEXT32 *in, uint32_t count) { VkDebugUtilsObjectNameInfoEXT *out; unsigned int i; @@ -39819,27 +39839,7 @@ static inline const VkDebugUtilsObjectNameInfoEXT *convert_VkDebugUtilsObjectNam return out; }

-#ifdef _WIN64 -static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win64_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT *in, VkDebugUtilsMessengerCallbackDataEXT *out) -{ - if (!in) return; - - out->sType = in->sType; - out->pNext = in->pNext; - out->flags = in->flags; - out->pMessageIdName = in->pMessageIdName; - out->messageIdNumber = in->messageIdNumber; - out->pMessage = in->pMessage; - out->queueLabelCount = in->queueLabelCount; - out->pQueueLabels = in->pQueueLabels; - out->cmdBufLabelCount = in->cmdBufLabelCount; - out->pCmdBufLabels = in->pCmdBufLabels; - out->objectCount = in->objectCount; - out->pObjects = convert_VkDebugUtilsObjectNameInfoEXT_array_win64_to_host(ctx, in->pObjects, in->objectCount); -} -#endif /* _WIN64 */ - -static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT32 *in, VkDebugUtilsMessengerCallbackDataEXT *out) +static void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(struct conversion_context *ctx, const VkDebugUtilsMessengerCallbackDataEXT32 *in, VkDebugUtilsMessengerCallbackDataEXT *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -39884,7 +39884,7 @@ static inline void convert_VkDebugUtilsMessengerCallbackDataEXT_win32_to_host(st } }

-static inline void convert_VkHostImageLayoutTransitionInfo_win32_to_host(const VkHostImageLayoutTransitionInfo32 *in, VkHostImageLayoutTransitionInfo *out) +static void convert_VkHostImageLayoutTransitionInfo_win32_to_host(const VkHostImageLayoutTransitionInfo32 *in, VkHostImageLayoutTransitionInfo *out) { if (!in) return;

@@ -39898,7 +39898,7 @@ static inline void convert_VkHostImageLayoutTransitionInfo_win32_to_host(const V FIXME("Unexpected pNext\n"); }

-static inline const VkHostImageLayoutTransitionInfo *convert_VkHostImageLayoutTransitionInfo_array_win32_to_host(struct conversion_context *ctx, const VkHostImageLayoutTransitionInfo32 *in, uint32_t count) +static const VkHostImageLayoutTransitionInfo *convert_VkHostImageLayoutTransitionInfo_array_win32_to_host(struct conversion_context *ctx, const VkHostImageLayoutTransitionInfo32 *in, uint32_t count) { VkHostImageLayoutTransitionInfo *out; unsigned int i; @@ -39915,7 +39915,7 @@ static inline const VkHostImageLayoutTransitionInfo *convert_VkHostImageLayoutTr }

#ifdef _WIN64 -static inline void convert_VkMemoryUnmapInfo_win64_to_host(const VkMemoryUnmapInfo *in, VkMemoryUnmapInfo *out) +static void convert_VkMemoryUnmapInfo_win64_to_host(const VkMemoryUnmapInfo *in, VkMemoryUnmapInfo *out) { if (!in) return;

@@ -39926,7 +39926,7 @@ static inline void convert_VkMemoryUnmapInfo_win64_to_host(const VkMemoryUnmapIn } #endif /* _WIN64 */

-static inline void convert_VkMemoryUnmapInfo_win32_to_host(const VkMemoryUnmapInfo32 *in, VkMemoryUnmapInfo *out) +static void convert_VkMemoryUnmapInfo_win32_to_host(const VkMemoryUnmapInfo32 *in, VkMemoryUnmapInfo *out) { if (!in) return;

@@ -39938,7 +39938,7 @@ static inline void convert_VkMemoryUnmapInfo_win32_to_host(const VkMemoryUnmapIn FIXME("Unexpected pNext\n"); }

-static inline void convert_VkMemoryUnmapInfo_win32_to_unwrapped_host(const VkMemoryUnmapInfo32 *in, VkMemoryUnmapInfo *out) +static void convert_VkMemoryUnmapInfo_win32_to_unwrapped_host(const VkMemoryUnmapInfo32 *in, VkMemoryUnmapInfo *out) { if (!in) return;

@@ -39950,7 +39950,7 @@ static inline void convert_VkMemoryUnmapInfo_win32_to_unwrapped_host(const VkMem FIXME("Unexpected pNext\n"); }

-static inline void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescriptorSet32 *in, VkCopyDescriptorSet *out) +static void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescriptorSet32 *in, VkCopyDescriptorSet *out) { if (!in) return;

@@ -39967,7 +39967,7 @@ static inline void convert_VkCopyDescriptorSet_win32_to_host(const VkCopyDescrip FIXME("Unexpected pNext\n"); }

-static inline const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkCopyDescriptorSet32 *in, uint32_t count) +static const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32_to_host(struct conversion_context *ctx, const VkCopyDescriptorSet32 *in, uint32_t count) { VkCopyDescriptorSet *out; unsigned int i; @@ -39983,7 +39983,7 @@ static inline const VkCopyDescriptorSet *convert_VkCopyDescriptorSet_array_win32 return out; }

-static inline void convert_VkWriteIndirectExecutionSetPipelineEXT_win32_to_host(const VkWriteIndirectExecutionSetPipelineEXT32 *in, VkWriteIndirectExecutionSetPipelineEXT *out) +static void convert_VkWriteIndirectExecutionSetPipelineEXT_win32_to_host(const VkWriteIndirectExecutionSetPipelineEXT32 *in, VkWriteIndirectExecutionSetPipelineEXT *out) { if (!in) return;

@@ -39995,7 +39995,7 @@ static inline void convert_VkWriteIndirectExecutionSetPipelineEXT_win32_to_host( FIXME("Unexpected pNext\n"); }

-static inline const VkWriteIndirectExecutionSetPipelineEXT *convert_VkWriteIndirectExecutionSetPipelineEXT_array_win32_to_host(struct conversion_context *ctx, const VkWriteIndirectExecutionSetPipelineEXT32 *in, uint32_t count) +static const VkWriteIndirectExecutionSetPipelineEXT *convert_VkWriteIndirectExecutionSetPipelineEXT_array_win32_to_host(struct conversion_context *ctx, const VkWriteIndirectExecutionSetPipelineEXT32 *in, uint32_t count) { VkWriteIndirectExecutionSetPipelineEXT *out; unsigned int i; @@ -40011,7 +40011,7 @@ static inline const VkWriteIndirectExecutionSetPipelineEXT *convert_VkWriteIndir return out; }

-static inline void convert_VkWriteIndirectExecutionSetShaderEXT_win32_to_host(const VkWriteIndirectExecutionSetShaderEXT32 *in, VkWriteIndirectExecutionSetShaderEXT *out) +static void convert_VkWriteIndirectExecutionSetShaderEXT_win32_to_host(const VkWriteIndirectExecutionSetShaderEXT32 *in, VkWriteIndirectExecutionSetShaderEXT *out) { if (!in) return;

@@ -40023,7 +40023,7 @@ static inline void convert_VkWriteIndirectExecutionSetShaderEXT_win32_to_host(co FIXME("Unexpected pNext\n"); }

-static inline const VkWriteIndirectExecutionSetShaderEXT *convert_VkWriteIndirectExecutionSetShaderEXT_array_win32_to_host(struct conversion_context *ctx, const VkWriteIndirectExecutionSetShaderEXT32 *in, uint32_t count) +static const VkWriteIndirectExecutionSetShaderEXT *convert_VkWriteIndirectExecutionSetShaderEXT_array_win32_to_host(struct conversion_context *ctx, const VkWriteIndirectExecutionSetShaderEXT32 *in, uint32_t count) { VkWriteIndirectExecutionSetShaderEXT *out; unsigned int i; @@ -40039,7 +40039,7 @@ static inline const VkWriteIndirectExecutionSetShaderEXT *convert_VkWriteIndirec return out; }

-static inline void convert_VkVideoSessionParametersUpdateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionParametersUpdateInfoKHR32 *in, VkVideoSessionParametersUpdateInfoKHR *out) +static void convert_VkVideoSessionParametersUpdateInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoSessionParametersUpdateInfoKHR32 *in, VkVideoSessionParametersUpdateInfoKHR *out) { const VkBaseInStructure32 *in_header; VkBaseOutStructure *out_header = (void *)out; @@ -40089,7 +40089,7 @@ static inline void convert_VkVideoSessionParametersUpdateInfoKHR_win32_to_host(s } }

-static inline void convert_VkPresentWait2InfoKHR_win32_to_host(const VkPresentWait2InfoKHR32 *in, VkPresentWait2InfoKHR *out) +static void convert_VkPresentWait2InfoKHR_win32_to_host(const VkPresentWait2InfoKHR32 *in, VkPresentWait2InfoKHR *out) { if (!in) return;

@@ -40101,7 +40101,7 @@ static inline void convert_VkPresentWait2InfoKHR_win32_to_host(const VkPresentWa FIXME("Unexpected pNext\n"); }

-static inline void convert_VkSemaphoreWaitInfo_win32_to_host(const VkSemaphoreWaitInfo32 *in, VkSemaphoreWaitInfo *out) +static void convert_VkSemaphoreWaitInfo_win32_to_host(const VkSemaphoreWaitInfo32 *in, VkSemaphoreWaitInfo *out) { if (!in) return;

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8901

Rémi Bernon

9:37 a.m.

New subject: [PATCH 3/6] winevulkan: Expose the VK_EXT_map_memory_placed extension.

From: Rémi Bernon rbernon@codeweavers.com

--- dlls/winevulkan/make_vulkan | 1 - dlls/winevulkan/vulkan_thunks.c | 1 + 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 68d0673719a..1360859454a 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -132,7 +132,6 @@ UNSUPPORTED_EXTENSIONS = [ # winevulkan may nonetheless use, or extensions we want to generate headers for # but not expose to applications (useful for test commits) UNEXPOSED_EXTENSIONS = { - "VK_EXT_map_memory_placed", "VK_KHR_external_memory_win32", "VK_EXT_headless_surface", # Extensions for other platforms diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index a9d1616def4..babd45a7be9 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -59058,6 +59058,7 @@ static const char * const vk_device_extensions[] = "VK_EXT_legacy_vertex_attributes", "VK_EXT_line_rasterization", "VK_EXT_load_store_op_none", + "VK_EXT_map_memory_placed", "VK_EXT_memory_budget", "VK_EXT_memory_priority", "VK_EXT_mesh_shader",

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8901

Rémi Bernon

9:37 a.m.

New subject: [PATCH 4/6] winevulkan: Build the struct extension list lazily.

From: Rémi Bernon rbernon@codeweavers.com

--- dlls/winevulkan/make_vulkan | 85 ++++++++++++++++++++----------------- 1 file changed, 45 insertions(+), 40 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 1360859454a..2fe905fe6ac 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -425,7 +425,7 @@ class VkDefine(object): self.value = value

@staticmethod - def from_xml(define): + def from_xml(registry, define): if not api_is_vulkan(define): return None

@@ -453,7 +453,7 @@ class VkEnum(object): self.aliased_by = []

@staticmethod - def from_alias(enum, alias): + def from_alias(registry, enum, alias): name = enum.attrib.get("name") aliasee = VkEnum(name, alias.bitwidth, alias=alias)

@@ -461,7 +461,7 @@ class VkEnum(object): return aliasee

@staticmethod - def from_xml(enum): + def from_xml(registry, enum): if not api_is_vulkan(enum): return None

@@ -620,7 +620,7 @@ class VkFunction(object): self.unwrap = Unwrap.HOST

@staticmethod - def from_alias(command, alias): + def from_alias(registry, command, alias): """ Create VkFunction from an alias command.

Args: @@ -640,7 +640,7 @@ class VkFunction(object): return VkFunction(_type=func_type, name=func_name, params=params, alias=alias)

@staticmethod - def from_xml(command, types): + def from_xml(registry, command, types): if not api_is_vulkan(command): return None

@@ -650,7 +650,7 @@ class VkFunction(object):

params = [] for param in command.findall("param"): - vk_param = VkParam.from_xml(param, types, params) + vk_param = VkParam.from_xml(registry, param, types, params) if vk_param: params.append(vk_param)

@@ -996,7 +996,7 @@ class VkFunctionPointer(object): self.required = False

@staticmethod - def from_xml(funcpointer): + def from_xml(registry, funcpointer): if not api_is_vulkan(funcpointer): return None

@@ -1024,12 +1024,12 @@ class VkHandle(object): self.object_type = None

@staticmethod - def from_alias(handle, alias): + def from_alias(registry, handle, alias): name = handle.attrib.get("name") return VkHandle(name, alias.type, alias.parent, alias=alias)

@staticmethod - def from_xml(handle): + def from_xml(registry, handle): if not api_is_vulkan(handle): return None

@@ -1340,7 +1340,7 @@ class VkMember(VkVariable): self.name, self.array_lens, self.dyn_array_len)

@staticmethod - def from_xml(member, returnedonly, parent): + def from_xml(registry, member, returnedonly, parent): """ Helper function for parsing a member tag within a struct or union. """

if not api_is_vulkan(member): @@ -1583,7 +1583,7 @@ class VkParam(VkVariable): return "{0} {1} {2} {3} {4} {5}".format(self.const, self.type, self.pointer, self.name, self.array_lens, self.dyn_array_len)

@staticmethod - def from_xml(param, types, parent): + def from_xml(registry, param, types, parent): """ Helper function to create VkParam from xml. """

if not api_is_vulkan(param): @@ -1879,7 +1879,8 @@ class VkParam(VkVariable): class VkStruct(Sequence): """ Class which represents the type union and struct. """

- def __init__(self, name, members, returnedonly, structextends, alias=None, union=False): + def __init__(self, registry, name, members, returnedonly, structextends, alias=None, union=False): + self.registry = registry self.name = name self.members = members self.returnedonly = returnedonly @@ -1888,7 +1889,7 @@ class VkStruct(Sequence): self.alias = alias self.union = union self.type_info = None # To be set later. - self.struct_extensions = [] + self._extensions = None self.aliased_by = [] self.order = 0

@@ -1899,15 +1900,15 @@ class VkStruct(Sequence): return len(self.members)

@staticmethod - def from_alias(struct, alias): + def from_alias(registry, struct, alias): name = struct.attrib.get("name") - aliasee = VkStruct(name, alias.members, alias.returnedonly, alias.structextends, alias=alias) + aliasee = VkStruct(registry, name, alias.members, alias.returnedonly, alias.structextends, alias=alias)

alias.add_aliased_by(aliasee) return aliasee

@staticmethod - def from_xml(struct): + def from_xml(registry, struct): if not api_is_vulkan(struct): return None

@@ -1933,9 +1934,9 @@ class VkStruct(Sequence): structextends = struct.attrib.get("structextends") structextends = structextends.split(",") if structextends else []

- s = VkStruct(name, [], returnedonly, structextends, union=union) + s = VkStruct(registry, name, [], returnedonly, structextends, union=union) for member in struct.findall("member"): - vk_member = VkMember.from_xml(member, returnedonly, s) + vk_member = VkMember.from_xml(registry, member, returnedonly, s) if vk_member: s.members.append(vk_member)

@@ -1955,6 +1956,21 @@ class VkStruct(Sequence): structs[member.type].alias.set_order(self.order, structs) structs[member.type].set_order(self.order, structs)

+ @property + def struct_extensions(self): + if self._extensions is None: + self._extensions = [] + + def is_struct_extension(s): + return not s.alias and self.name in s.structextends + + for type_info in self.registry.types.values(): + struct = type_info["data"] if type_info["category"] == "struct" else None + if struct and is_struct_extension(struct): + self._extensions.append(struct) + + return self._extensions + def definition(self, align=False, conv=False): """ Convert structure to textual definition.

@@ -3187,14 +3203,14 @@ class VkRegistry(object): alias_commands.append(command) continue

- func = VkFunction.from_xml(command, self.types) + func = VkFunction.from_xml(self, command, self.types) if func: funcs[func.name] = func

for command in alias_commands: alias_name = command.attrib.get("alias") alias = funcs[alias_name] - func = VkFunction.from_alias(command, alias) + func = VkFunction.from_alias(self, command, alias) if func: funcs[func.name] = func

@@ -3234,7 +3250,7 @@ class VkRegistry(object): _type = enum.attrib.get("type")

if _type in ("enum", "bitmask"): - enum_obj = VkEnum.from_xml(enum) + enum_obj = VkEnum.from_xml(self, enum) if enum_obj: enums[name] = enum_obj else: @@ -3521,7 +3537,7 @@ class VkRegistry(object):

if type_info["category"] == "basetype": name = t.find("name").text - define = VkDefine.from_xml(t) + define = VkDefine.from_xml(self, t) defines.append(define) type_info["data"] = define

@@ -3544,7 +3560,7 @@ class VkRegistry(object): type_info["data"] = bitmask

elif type_info["category"] == "define": - define = VkDefine.from_xml(t) + define = VkDefine.from_xml(self, t) if define: defines.append(define) type_info["data"] = define @@ -3564,7 +3580,7 @@ class VkRegistry(object): type_info["data"] = None

elif type_info["category"] == "funcpointer": - funcpointer = VkFunctionPointer.from_xml(t) + funcpointer = VkFunctionPointer.from_xml(self, t) if funcpointer: funcpointers.append(funcpointer) type_info["data"] = funcpointer @@ -3572,7 +3588,7 @@ class VkRegistry(object): continue

elif type_info["category"] == "handle": - handle = VkHandle.from_xml(t) + handle = VkHandle.from_xml(self, t) if handle: handles.append(handle) type_info["data"] = handle @@ -3584,7 +3600,7 @@ class VkRegistry(object): # on unions. The types are very similar in parsing and # generation anyway. The official Vulkan scripts use # a similar kind of hack. - struct = VkStruct.from_xml(t) + struct = VkStruct.from_xml(self, t) if struct: structs.append(struct) type_info["data"] = struct @@ -3619,17 +3635,17 @@ class VkRegistry(object): type_info["data"] = bitmask

if type_info["category"] == "enum": - enum = VkEnum.from_alias(t, self.types[alias]["data"]) + enum = VkEnum.from_alias(self, t, self.types[alias]["data"]) type_info["data"] = enum self.enums[enum.name] = enum

if type_info["category"] == "handle": - handle = VkHandle.from_alias(t, self.types[alias]["data"]) + handle = VkHandle.from_alias(self, t, self.types[alias]["data"]) handles.append(handle) type_info["data"] = handle

if type_info["category"] == "struct": - struct = VkStruct.from_alias(t, self.types[alias]["data"]) + struct = VkStruct.from_alias(self, t, self.types[alias]["data"]) structs.append(struct) type_info["data"] = struct

@@ -3644,17 +3660,6 @@ class VkRegistry(object): for struct in structs.values(): struct.set_type_info(self.types)

- # Alias structures have enum values equivalent to those of the - # structure which they are aliased against. we need to ignore alias - # structs when populating the struct extensions list, otherwise we - # will create duplicate case entries. - if struct.alias: - continue - - for structextend in struct.structextends: - s = self.types[structextend]["data"] - s.struct_extensions.append(struct) - for struct in structs.values(): struct.set_order(0, structs)

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8901

Rémi Bernon

9:37 a.m.

New subject: [PATCH 5/6] winevulkan: Enumerate struct extensions with the registry structs.

From: Rémi Bernon rbernon@codeweavers.com

--- dlls/winevulkan/make_vulkan | 7 +- dlls/winevulkan/vulkan_thunks.c | 17302 +++++++++++++++--------------- 2 files changed, 8654 insertions(+), 8655 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 2fe905fe6ac..40726fc6e2e 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -1964,10 +1964,9 @@ class VkStruct(Sequence): def is_struct_extension(s): return not s.alias and self.name in s.structextends

- for type_info in self.registry.types.values(): - struct = type_info["data"] if type_info["category"] == "struct" else None - if struct and is_struct_extension(struct): - self._extensions.append(struct) + structs = sorted(self.registry.structs, key=lambda s: s.name) + for struct in filter(is_struct_extension, structs): + self._extensions.append(struct)

return self._extensions

diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index babd45a7be9..eb5c1921dbc 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -9698,27 +9698,39 @@ static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: { - VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImportMemoryWin32HandleInfoKHR32 *in_ext = (const VkImportMemoryWin32HandleInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkExportMemoryWin32HandleInfoKHR32 *in_ext = (const VkExportMemoryWin32HandleInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; out_ext->pNext = NULL; - out_ext->handleType = in_ext->handleType; - out_ext->handle = in_ext->handle; + out_ext->pAttributes = UlongToPtr(in_ext->pAttributes); + out_ext->dwAccess = in_ext->dwAccess; out_ext->name = in_ext->name; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: { - VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkExportMemoryWin32HandleInfoKHR32 *in_ext = (const VkExportMemoryWin32HandleInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImportMemoryHostPointerInfoEXT32 *in_ext = (const VkImportMemoryHostPointerInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT; out_ext->pNext = NULL; - out_ext->pAttributes = UlongToPtr(in_ext->pAttributes); - out_ext->dwAccess = in_ext->dwAccess; + out_ext->handleType = in_ext->handleType; + out_ext->pHostPointer = UlongToPtr(in_ext->pHostPointer); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + { + VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImportMemoryWin32HandleInfoKHR32 *in_ext = (const VkImportMemoryWin32HandleInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->handleType = in_ext->handleType; + out_ext->handle = in_ext->handle; out_ext->name = in_ext->name; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -9748,25 +9760,13 @@ static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: - { - VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImportMemoryHostPointerInfoEXT32 *in_ext = (const VkImportMemoryHostPointerInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT; - out_ext->pNext = NULL; - out_ext->handleType = in_ext->handleType; - out_ext->pHostPointer = UlongToPtr(in_ext->pHostPointer); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: { - VkMemoryPriorityAllocateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkMemoryPriorityAllocateInfoEXT32 *in_ext = (const VkMemoryPriorityAllocateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT; + VkMemoryDedicatedAllocateInfoTensorARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkMemoryDedicatedAllocateInfoTensorARM32 *in_ext = (const VkMemoryDedicatedAllocateInfoTensorARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM; out_ext->pNext = NULL; - out_ext->priority = in_ext->priority; + out_ext->tensor = in_ext->tensor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -9782,13 +9782,13 @@ static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: { - VkMemoryDedicatedAllocateInfoTensorARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkMemoryDedicatedAllocateInfoTensorARM32 *in_ext = (const VkMemoryDedicatedAllocateInfoTensorARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM; + VkMemoryPriorityAllocateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkMemoryPriorityAllocateInfoEXT32 *in_ext = (const VkMemoryPriorityAllocateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->tensor = in_ext->tensor; + out_ext->priority = in_ext->priority; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -9862,6 +9862,19 @@ static void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct conversi { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: + { + VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; + out_ext->pNext = NULL; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples; + out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: { VkCommandBufferInheritanceConditionalRenderingInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -9885,19 +9898,6 @@ static void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct conversi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: - { - VkCommandBufferInheritanceViewportScissorInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkCommandBufferInheritanceViewportScissorInfoNV *in_ext = (const VkCommandBufferInheritanceViewportScissorInfoNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV; - out_ext->pNext = NULL; - out_ext->viewportScissor2D = in_ext->viewportScissor2D; - out_ext->viewportDepthCount = in_ext->viewportDepthCount; - out_ext->pViewportDepths = in_ext->pViewportDepths; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: { VkCommandBufferInheritanceRenderingInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -9915,26 +9915,27 @@ static void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct conversi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: { - VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; + VkCommandBufferInheritanceViewportScissorInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkCommandBufferInheritanceViewportScissorInfoNV *in_ext = (const VkCommandBufferInheritanceViewportScissorInfoNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV; out_ext->pNext = NULL; - out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; - out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples; - out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples; + out_ext->viewportScissor2D = in_ext->viewportScissor2D; + out_ext->viewportDepthCount = in_ext->viewportDepthCount; + out_ext->pViewportDepths = in_ext->pViewportDepths; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM: + case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: { - VkTileMemoryBindInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkTileMemoryBindInfoQCOM *in_ext = (const VkTileMemoryBindInfoQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM; + VkRenderPassTileShadingCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderPassTileShadingCreateInfoQCOM *in_ext = (const VkRenderPassTileShadingCreateInfoQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; out_ext->pNext = NULL; - out_ext->memory = vulkan_device_memory_from_handle(in_ext->memory)->host.device_memory; + out_ext->flags = in_ext->flags; + out_ext->tileApronSize = in_ext->tileApronSize; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -9965,14 +9966,13 @@ static void convert_VkCommandBufferInheritanceInfo_win64_to_host(struct conversi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: + case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM: { - VkRenderPassTileShadingCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRenderPassTileShadingCreateInfoQCOM *in_ext = (const VkRenderPassTileShadingCreateInfoQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; + VkTileMemoryBindInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkTileMemoryBindInfoQCOM *in_ext = (const VkTileMemoryBindInfoQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->tileApronSize = in_ext->tileApronSize; + out_ext->memory = vulkan_device_memory_from_handle(in_ext->memory)->host.device_memory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -10035,6 +10035,19 @@ static void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversi { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: + { + VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; + out_ext->pNext = NULL; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentSamples = UlongToPtr(in_ext->pColorAttachmentSamples); + out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: { VkCommandBufferInheritanceConditionalRenderingInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -10058,19 +10071,6 @@ static void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: - { - VkCommandBufferInheritanceViewportScissorInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkCommandBufferInheritanceViewportScissorInfoNV32 *in_ext = (const VkCommandBufferInheritanceViewportScissorInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV; - out_ext->pNext = NULL; - out_ext->viewportScissor2D = in_ext->viewportScissor2D; - out_ext->viewportDepthCount = in_ext->viewportDepthCount; - out_ext->pViewportDepths = UlongToPtr(in_ext->pViewportDepths); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: { VkCommandBufferInheritanceRenderingInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -10088,26 +10088,27 @@ static void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: { - VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; + VkCommandBufferInheritanceViewportScissorInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkCommandBufferInheritanceViewportScissorInfoNV32 *in_ext = (const VkCommandBufferInheritanceViewportScissorInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV; out_ext->pNext = NULL; - out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; - out_ext->pColorAttachmentSamples = UlongToPtr(in_ext->pColorAttachmentSamples); - out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples; + out_ext->viewportScissor2D = in_ext->viewportScissor2D; + out_ext->viewportDepthCount = in_ext->viewportDepthCount; + out_ext->pViewportDepths = UlongToPtr(in_ext->pViewportDepths); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM: + case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: { - VkTileMemoryBindInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkTileMemoryBindInfoQCOM32 *in_ext = (const VkTileMemoryBindInfoQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM; + VkRenderPassTileShadingCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderPassTileShadingCreateInfoQCOM32 *in_ext = (const VkRenderPassTileShadingCreateInfoQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; out_ext->pNext = NULL; - out_ext->memory = vulkan_device_memory_from_handle(in_ext->memory)->host.device_memory; + out_ext->flags = in_ext->flags; + out_ext->tileApronSize = in_ext->tileApronSize; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -10138,14 +10139,13 @@ static void convert_VkCommandBufferInheritanceInfo_win32_to_host(struct conversi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: + case VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM: { - VkRenderPassTileShadingCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRenderPassTileShadingCreateInfoQCOM32 *in_ext = (const VkRenderPassTileShadingCreateInfoQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; + VkTileMemoryBindInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkTileMemoryBindInfoQCOM32 *in_ext = (const VkTileMemoryBindInfoQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->tileApronSize = in_ext->tileApronSize; + out_ext->memory = vulkan_device_memory_from_handle(in_ext->memory)->host.device_memory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -11186,16 +11186,14 @@ static void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: { - VkRenderPassSampleLocationsBeginInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRenderPassSampleLocationsBeginInfoEXT32 *in_ext = (const VkRenderPassSampleLocationsBeginInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT; + VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM; out_ext->pNext = NULL; - out_ext->attachmentInitialSampleLocationsCount = in_ext->attachmentInitialSampleLocationsCount; - out_ext->pAttachmentInitialSampleLocations = convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(ctx, (const VkAttachmentSampleLocationsEXT32 *)UlongToPtr(in_ext->pAttachmentInitialSampleLocations), in_ext->attachmentInitialSampleLocationsCount); - out_ext->postSubpassSampleLocationsCount = in_ext->postSubpassSampleLocationsCount; - out_ext->pPostSubpassSampleLocations = convert_VkSubpassSampleLocationsEXT_array_win32_to_host(ctx, (const VkSubpassSampleLocationsEXT32 *)UlongToPtr(in_ext->pPostSubpassSampleLocations), in_ext->postSubpassSampleLocationsCount); + out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount; + out_ext->pPerViewRenderAreas = UlongToPtr(in_ext->pPerViewRenderAreas); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -11212,25 +11210,16 @@ static void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: - { - VkRenderPassTransformBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRenderPassTransformBeginInfoQCOM32 *in_ext = (const VkRenderPassTransformBeginInfoQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM; - out_ext->pNext = NULL; - out_ext->transform = in_ext->transform; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: { - VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM; + VkRenderPassSampleLocationsBeginInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderPassSampleLocationsBeginInfoEXT32 *in_ext = (const VkRenderPassSampleLocationsBeginInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT; out_ext->pNext = NULL; - out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount; - out_ext->pPerViewRenderAreas = UlongToPtr(in_ext->pPerViewRenderAreas); + out_ext->attachmentInitialSampleLocationsCount = in_ext->attachmentInitialSampleLocationsCount; + out_ext->pAttachmentInitialSampleLocations = convert_VkAttachmentSampleLocationsEXT_array_win32_to_host(ctx, (const VkAttachmentSampleLocationsEXT32 *)UlongToPtr(in_ext->pAttachmentInitialSampleLocations), in_ext->attachmentInitialSampleLocationsCount); + out_ext->postSubpassSampleLocationsCount = in_ext->postSubpassSampleLocationsCount; + out_ext->pPostSubpassSampleLocations = convert_VkSubpassSampleLocationsEXT_array_win32_to_host(ctx, (const VkSubpassSampleLocationsEXT32 *)UlongToPtr(in_ext->pPostSubpassSampleLocations), in_ext->postSubpassSampleLocationsCount); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -11247,6 +11236,17 @@ static void convert_VkRenderPassBeginInfo_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: + { + VkRenderPassTransformBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderPassTransformBeginInfoQCOM32 *in_ext = (const VkRenderPassTransformBeginInfoQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM; + out_ext->pNext = NULL; + out_ext->transform = in_ext->transform; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -11368,74 +11368,74 @@ static void convert_VkRenderingInfo_win32_to_host(struct conversion_context *ctx out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: { - VkRenderingFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; + VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM; out_ext->pNext = NULL; - out_ext->imageView = in_ext->imageView; - out_ext->imageLayout = in_ext->imageLayout; - out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize; + out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount; + out_ext->pPerViewRenderAreas = UlongToPtr(in_ext->pPerViewRenderAreas); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: + case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: { - VkRenderingFragmentDensityMapAttachmentInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *in_ext = (const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; + VkRenderPassStripeBeginInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderPassStripeBeginInfoARM32 *in_ext = (const VkRenderPassStripeBeginInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM; out_ext->pNext = NULL; - out_ext->imageView = in_ext->imageView; - out_ext->imageLayout = in_ext->imageLayout; + out_ext->stripeInfoCount = in_ext->stripeInfoCount; + out_ext->pStripeInfos = convert_VkRenderPassStripeInfoARM_array_win32_to_host(ctx, (const VkRenderPassStripeInfoARM32 *)UlongToPtr(in_ext->pStripeInfos), in_ext->stripeInfoCount); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: + case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: { - VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *in_ext = (const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM; + VkRenderPassTileShadingCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderPassTileShadingCreateInfoQCOM32 *in_ext = (const VkRenderPassTileShadingCreateInfoQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; out_ext->pNext = NULL; - out_ext->perViewRenderAreaCount = in_ext->perViewRenderAreaCount; - out_ext->pPerViewRenderAreas = UlongToPtr(in_ext->pPerViewRenderAreas); + out_ext->flags = in_ext->flags; + out_ext->tileApronSize = in_ext->tileApronSize; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: { - VkTileMemorySizeInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkTileMemorySizeInfoQCOM32 *in_ext = (const VkTileMemorySizeInfoQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM; + VkRenderingFragmentDensityMapAttachmentInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *in_ext = (const VkRenderingFragmentDensityMapAttachmentInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT; out_ext->pNext = NULL; - out_ext->size = in_ext->size; + out_ext->imageView = in_ext->imageView; + out_ext->imageLayout = in_ext->imageLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: { - VkRenderPassStripeBeginInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRenderPassStripeBeginInfoARM32 *in_ext = (const VkRenderPassStripeBeginInfoARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM; + VkRenderingFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *in_ext = (const VkRenderingFragmentShadingRateAttachmentInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR; out_ext->pNext = NULL; - out_ext->stripeInfoCount = in_ext->stripeInfoCount; - out_ext->pStripeInfos = convert_VkRenderPassStripeInfoARM_array_win32_to_host(ctx, (const VkRenderPassStripeInfoARM32 *)UlongToPtr(in_ext->pStripeInfos), in_ext->stripeInfoCount); + out_ext->imageView = in_ext->imageView; + out_ext->imageLayout = in_ext->imageLayout; + out_ext->shadingRateAttachmentTexelSize = in_ext->shadingRateAttachmentTexelSize; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: + case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: { - VkRenderPassTileShadingCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRenderPassTileShadingCreateInfoQCOM32 *in_ext = (const VkRenderPassTileShadingCreateInfoQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM; + VkTileMemorySizeInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkTileMemorySizeInfoQCOM32 *in_ext = (const VkTileMemorySizeInfoQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->tileApronSize = in_ext->tileApronSize; + out_ext->size = in_ext->size; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -11521,17 +11521,6 @@ static void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conversion_ { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: - { - VkVideoDecodeH264DpbSlotInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoDecodeH264DpbSlotInfoKHR32 *in_ext = (const VkVideoDecodeH264DpbSlotInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR; - out_ext->pNext = NULL; - out_ext->pStdReferenceInfo = UlongToPtr(in_ext->pStdReferenceInfo); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: { VkVideoDecodeAV1DpbSlotInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -11543,11 +11532,11 @@ static void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: { - VkVideoEncodeH264DpbSlotInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeH264DpbSlotInfoKHR32 *in_ext = (const VkVideoEncodeH264DpbSlotInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR; + VkVideoDecodeH264DpbSlotInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoDecodeH264DpbSlotInfoKHR32 *in_ext = (const VkVideoDecodeH264DpbSlotInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR; out_ext->pNext = NULL; out_ext->pStdReferenceInfo = UlongToPtr(in_ext->pStdReferenceInfo); out_header->pNext = (void *)out_ext; @@ -11565,6 +11554,17 @@ static void convert_VkVideoReferenceSlotInfoKHR_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: + { + VkVideoEncodeH264DpbSlotInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeH264DpbSlotInfoKHR32 *in_ext = (const VkVideoEncodeH264DpbSlotInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR; + out_ext->pNext = NULL; + out_ext->pStdReferenceInfo = UlongToPtr(in_ext->pStdReferenceInfo); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR: { VkVideoReferenceIntraRefreshInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -11617,22 +11617,6 @@ static void convert_VkVideoEncodeRateControlLayerInfoKHR_win32_to_host(struct co { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: - { - VkVideoEncodeH264RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeH264RateControlLayerInfoKHR32 *in_ext = (const VkVideoEncodeH264RateControlLayerInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR; - out_ext->pNext = NULL; - out_ext->useMinQp = in_ext->useMinQp; - out_ext->minQp = in_ext->minQp; - out_ext->useMaxQp = in_ext->useMaxQp; - out_ext->maxQp = in_ext->maxQp; - out_ext->useMaxFrameSize = in_ext->useMaxFrameSize; - out_ext->maxFrameSize = in_ext->maxFrameSize; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: { VkVideoEncodeAV1RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -11649,6 +11633,22 @@ static void convert_VkVideoEncodeRateControlLayerInfoKHR_win32_to_host(struct co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: + { + VkVideoEncodeH264RateControlLayerInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeH264RateControlLayerInfoKHR32 *in_ext = (const VkVideoEncodeH264RateControlLayerInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR; + out_ext->pNext = NULL; + out_ext->useMinQp = in_ext->useMinQp; + out_ext->minQp = in_ext->minQp; + out_ext->useMaxQp = in_ext->useMaxQp; + out_ext->maxQp = in_ext->maxQp; + out_ext->useMaxFrameSize = in_ext->useMaxFrameSize; + out_ext->maxFrameSize = in_ext->maxFrameSize; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -11691,32 +11691,30 @@ static void convert_VkVideoBeginCodingInfoKHR_win32_to_host(struct conversion_co { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR: { - VkVideoEncodeRateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeRateControlInfoKHR32 *in_ext = (const VkVideoEncodeRateControlInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; + VkVideoEncodeAV1GopRemainingFrameInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1GopRemainingFrameInfoKHR32 *in_ext = (const VkVideoEncodeAV1GopRemainingFrameInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->rateControlMode = in_ext->rateControlMode; - out_ext->layerCount = in_ext->layerCount; - out_ext->pLayers = convert_VkVideoEncodeRateControlLayerInfoKHR_array_win32_to_host(ctx, (const VkVideoEncodeRateControlLayerInfoKHR32 *)UlongToPtr(in_ext->pLayers), in_ext->layerCount); - out_ext->virtualBufferSizeInMs = in_ext->virtualBufferSizeInMs; - out_ext->initialVirtualBufferSizeInMs = in_ext->initialVirtualBufferSizeInMs; + out_ext->useGopRemainingFrames = in_ext->useGopRemainingFrames; + out_ext->gopRemainingIntra = in_ext->gopRemainingIntra; + out_ext->gopRemainingPredictive = in_ext->gopRemainingPredictive; + out_ext->gopRemainingBipredictive = in_ext->gopRemainingBipredictive; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: { - VkVideoEncodeH264RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeH264RateControlInfoKHR32 *in_ext = (const VkVideoEncodeH264RateControlInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR; + VkVideoEncodeAV1RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1RateControlInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; out_ext->pNext = NULL; out_ext->flags = in_ext->flags; out_ext->gopFrameCount = in_ext->gopFrameCount; - out_ext->idrPeriod = in_ext->idrPeriod; - out_ext->consecutiveBFrameCount = in_ext->consecutiveBFrameCount; + out_ext->keyFramePeriod = in_ext->keyFramePeriod; + out_ext->consecutiveBipredictiveFrameCount = in_ext->consecutiveBipredictiveFrameCount; out_ext->temporalLayerCount = in_ext->temporalLayerCount; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -11736,31 +11734,33 @@ static void convert_VkVideoBeginCodingInfoKHR_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: { - VkVideoEncodeAV1RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeAV1RateControlInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; + VkVideoEncodeH264RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeH264RateControlInfoKHR32 *in_ext = (const VkVideoEncodeH264RateControlInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR; out_ext->pNext = NULL; out_ext->flags = in_ext->flags; out_ext->gopFrameCount = in_ext->gopFrameCount; - out_ext->keyFramePeriod = in_ext->keyFramePeriod; - out_ext->consecutiveBipredictiveFrameCount = in_ext->consecutiveBipredictiveFrameCount; + out_ext->idrPeriod = in_ext->idrPeriod; + out_ext->consecutiveBFrameCount = in_ext->consecutiveBFrameCount; out_ext->temporalLayerCount = in_ext->temporalLayerCount; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: { - VkVideoEncodeAV1GopRemainingFrameInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeAV1GopRemainingFrameInfoKHR32 *in_ext = (const VkVideoEncodeAV1GopRemainingFrameInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR; + VkVideoEncodeRateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeRateControlInfoKHR32 *in_ext = (const VkVideoEncodeRateControlInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; out_ext->pNext = NULL; - out_ext->useGopRemainingFrames = in_ext->useGopRemainingFrames; - out_ext->gopRemainingIntra = in_ext->gopRemainingIntra; - out_ext->gopRemainingPredictive = in_ext->gopRemainingPredictive; - out_ext->gopRemainingBipredictive = in_ext->gopRemainingBipredictive; + out_ext->flags = in_ext->flags; + out_ext->rateControlMode = in_ext->rateControlMode; + out_ext->layerCount = in_ext->layerCount; + out_ext->pLayers = convert_VkVideoEncodeRateControlLayerInfoKHR_array_win32_to_host(ctx, (const VkVideoEncodeRateControlLayerInfoKHR32 *)UlongToPtr(in_ext->pLayers), in_ext->layerCount); + out_ext->virtualBufferSizeInMs = in_ext->virtualBufferSizeInMs; + out_ext->initialVirtualBufferSizeInMs = in_ext->initialVirtualBufferSizeInMs; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -12356,29 +12356,17 @@ static void convert_VkVideoCodingControlInfoKHR_win32_to_host(struct conversion_ { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: - { - VkVideoEncodeQualityLevelInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeQualityLevelInfoKHR32 *in_ext = (const VkVideoEncodeQualityLevelInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; - out_ext->pNext = NULL; - out_ext->qualityLevel = in_ext->qualityLevel; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: { - VkVideoEncodeRateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeRateControlInfoKHR32 *in_ext = (const VkVideoEncodeRateControlInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; + VkVideoEncodeAV1RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1RateControlInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; out_ext->pNext = NULL; out_ext->flags = in_ext->flags; - out_ext->rateControlMode = in_ext->rateControlMode; - out_ext->layerCount = in_ext->layerCount; - out_ext->pLayers = convert_VkVideoEncodeRateControlLayerInfoKHR_array_win32_to_host(ctx, (const VkVideoEncodeRateControlLayerInfoKHR32 *)UlongToPtr(in_ext->pLayers), in_ext->layerCount); - out_ext->virtualBufferSizeInMs = in_ext->virtualBufferSizeInMs; - out_ext->initialVirtualBufferSizeInMs = in_ext->initialVirtualBufferSizeInMs; + out_ext->gopFrameCount = in_ext->gopFrameCount; + out_ext->keyFramePeriod = in_ext->keyFramePeriod; + out_ext->consecutiveBipredictiveFrameCount = in_ext->consecutiveBipredictiveFrameCount; + out_ext->temporalLayerCount = in_ext->temporalLayerCount; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -12398,17 +12386,29 @@ static void convert_VkVideoCodingControlInfoKHR_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: { - VkVideoEncodeAV1RateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeAV1RateControlInfoKHR32 *in_ext = (const VkVideoEncodeAV1RateControlInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR; + VkVideoEncodeQualityLevelInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeQualityLevelInfoKHR32 *in_ext = (const VkVideoEncodeQualityLevelInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR; + out_ext->pNext = NULL; + out_ext->qualityLevel = in_ext->qualityLevel; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: + { + VkVideoEncodeRateControlInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeRateControlInfoKHR32 *in_ext = (const VkVideoEncodeRateControlInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR; out_ext->pNext = NULL; out_ext->flags = in_ext->flags; - out_ext->gopFrameCount = in_ext->gopFrameCount; - out_ext->keyFramePeriod = in_ext->keyFramePeriod; - out_ext->consecutiveBipredictiveFrameCount = in_ext->consecutiveBipredictiveFrameCount; - out_ext->temporalLayerCount = in_ext->temporalLayerCount; + out_ext->rateControlMode = in_ext->rateControlMode; + out_ext->layerCount = in_ext->layerCount; + out_ext->pLayers = convert_VkVideoEncodeRateControlLayerInfoKHR_array_win32_to_host(ctx, (const VkVideoEncodeRateControlLayerInfoKHR32 *)UlongToPtr(in_ext->pLayers), in_ext->layerCount); + out_ext->virtualBufferSizeInMs = in_ext->virtualBufferSizeInMs; + out_ext->initialVirtualBufferSizeInMs = in_ext->initialVirtualBufferSizeInMs; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -12841,47 +12841,7 @@ static void convert_VkDebugMarkerMarkerInfoEXT_win32_to_host(const VkDebugMarker FIXME("Unexpected pNext\n"); }

-static void convert_StdVideoDecodeVP9PictureInfo_win32_to_host(const StdVideoDecodeVP9PictureInfo32 *in, StdVideoDecodeVP9PictureInfo *out) -{ - if (!in) return; - - out->flags = in->flags; - out->profile = in->profile; - out->frame_type = in->frame_type; - out->frame_context_idx = in->frame_context_idx; - out->reset_frame_context = in->reset_frame_context; - out->refresh_frame_flags = in->refresh_frame_flags; - out->ref_frame_sign_bias_mask = in->ref_frame_sign_bias_mask; - out->interpolation_filter = in->interpolation_filter; - out->base_q_idx = in->base_q_idx; - out->delta_q_y_dc = in->delta_q_y_dc; - out->delta_q_uv_dc = in->delta_q_uv_dc; - out->delta_q_uv_ac = in->delta_q_uv_ac; - out->tile_cols_log2 = in->tile_cols_log2; - out->tile_rows_log2 = in->tile_rows_log2; - memcpy(out->reserved1, in->reserved1, 3 * sizeof(uint16_t)); - out->pColorConfig = UlongToPtr(in->pColorConfig); - out->pLoopFilter = UlongToPtr(in->pLoopFilter); - out->pSegmentation = UlongToPtr(in->pSegmentation); -} - -static const StdVideoDecodeVP9PictureInfo *convert_StdVideoDecodeVP9PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeVP9PictureInfo32 *in, uint32_t count) -{ - StdVideoDecodeVP9PictureInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_StdVideoDecodeVP9PictureInfo_win32_to_host(&in[i], &out[i]); - } - - return out; -} - -static void convert_StdVideoAV1TileInfo_win32_to_host(const StdVideoAV1TileInfo32 *in, StdVideoAV1TileInfo *out) +static void convert_StdVideoAV1TileInfo_win32_to_host(const StdVideoAV1TileInfo32 *in, StdVideoAV1TileInfo *out) { if (!in) return;

@@ -12959,6 +12919,46 @@ static const StdVideoDecodeAV1PictureInfo *convert_StdVideoDecodeAV1PictureInfo_ return out; }

+static void convert_StdVideoDecodeVP9PictureInfo_win32_to_host(const StdVideoDecodeVP9PictureInfo32 *in, StdVideoDecodeVP9PictureInfo *out) +{ + if (!in) return; + + out->flags = in->flags; + out->profile = in->profile; + out->frame_type = in->frame_type; + out->frame_context_idx = in->frame_context_idx; + out->reset_frame_context = in->reset_frame_context; + out->refresh_frame_flags = in->refresh_frame_flags; + out->ref_frame_sign_bias_mask = in->ref_frame_sign_bias_mask; + out->interpolation_filter = in->interpolation_filter; + out->base_q_idx = in->base_q_idx; + out->delta_q_y_dc = in->delta_q_y_dc; + out->delta_q_uv_dc = in->delta_q_uv_dc; + out->delta_q_uv_ac = in->delta_q_uv_ac; + out->tile_cols_log2 = in->tile_cols_log2; + out->tile_rows_log2 = in->tile_rows_log2; + memcpy(out->reserved1, in->reserved1, 3 * sizeof(uint16_t)); + out->pColorConfig = UlongToPtr(in->pColorConfig); + out->pLoopFilter = UlongToPtr(in->pLoopFilter); + out->pSegmentation = UlongToPtr(in->pSegmentation); +} + +static const StdVideoDecodeVP9PictureInfo *convert_StdVideoDecodeVP9PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoDecodeVP9PictureInfo32 *in, uint32_t count) +{ + StdVideoDecodeVP9PictureInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_StdVideoDecodeVP9PictureInfo_win32_to_host(&in[i], &out[i]); + } + + return out; +} + static void convert_VkVideoDecodeInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoDecodeInfoKHR32 *in, VkVideoDecodeInfoKHR *out) { const VkBaseInStructure32 *in_header; @@ -12981,15 +12981,18 @@ static void convert_VkVideoDecodeInfoKHR_win32_to_host(struct conversion_context { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR: { - VkVideoInlineQueryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoInlineQueryInfoKHR32 *in_ext = (const VkVideoInlineQueryInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; + VkVideoDecodeAV1PictureInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoDecodeAV1PictureInfoKHR32 *in_ext = (const VkVideoDecodeAV1PictureInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR; out_ext->pNext = NULL; - out_ext->queryPool = in_ext->queryPool; - out_ext->firstQuery = in_ext->firstQuery; - out_ext->queryCount = in_ext->queryCount; + out_ext->pStdPictureInfo = convert_StdVideoDecodeAV1PictureInfo_array_win32_to_host(ctx, (const StdVideoDecodeAV1PictureInfo32 *)UlongToPtr(in_ext->pStdPictureInfo), 1); + memcpy(out_ext->referenceNameSlotIndices, in_ext->referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR * sizeof(int32_t)); + out_ext->frameHeaderOffset = in_ext->frameHeaderOffset; + out_ext->tileCount = in_ext->tileCount; + out_ext->pTileOffsets = UlongToPtr(in_ext->pTileOffsets); + out_ext->pTileSizes = UlongToPtr(in_ext->pTileSizes); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -13022,18 +13025,15 @@ static void convert_VkVideoDecodeInfoKHR_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: { - VkVideoDecodeAV1PictureInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoDecodeAV1PictureInfoKHR32 *in_ext = (const VkVideoDecodeAV1PictureInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR; + VkVideoInlineQueryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoInlineQueryInfoKHR32 *in_ext = (const VkVideoInlineQueryInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; out_ext->pNext = NULL; - out_ext->pStdPictureInfo = convert_StdVideoDecodeAV1PictureInfo_array_win32_to_host(ctx, (const StdVideoDecodeAV1PictureInfo32 *)UlongToPtr(in_ext->pStdPictureInfo), 1); - memcpy(out_ext->referenceNameSlotIndices, in_ext->referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR * sizeof(int32_t)); - out_ext->frameHeaderOffset = in_ext->frameHeaderOffset; - out_ext->tileCount = in_ext->tileCount; - out_ext->pTileOffsets = UlongToPtr(in_ext->pTileOffsets); - out_ext->pTileSizes = UlongToPtr(in_ext->pTileSizes); + out_ext->queryPool = in_ext->queryPool; + out_ext->firstQuery = in_ext->firstQuery; + out_ext->queryCount = in_ext->queryCount; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -13093,6 +13093,55 @@ static void convert_VkDispatchTileInfoQCOM_win32_to_host(const VkDispatchTileInf FIXME("Unexpected pNext\n"); }

+static void convert_StdVideoEncodeAV1PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, StdVideoEncodeAV1PictureInfo *out) +{ + if (!in) return; + + out->flags = in->flags; + out->frame_type = in->frame_type; + out->frame_presentation_time = in->frame_presentation_time; + out->current_frame_id = in->current_frame_id; + out->order_hint = in->order_hint; + out->primary_ref_frame = in->primary_ref_frame; + out->refresh_frame_flags = in->refresh_frame_flags; + out->coded_denom = in->coded_denom; + out->render_width_minus_1 = in->render_width_minus_1; + out->render_height_minus_1 = in->render_height_minus_1; + out->interpolation_filter = in->interpolation_filter; + out->TxMode = in->TxMode; + out->delta_q_res = in->delta_q_res; + out->delta_lf_res = in->delta_lf_res; + memcpy(out->ref_order_hint, in->ref_order_hint, STD_VIDEO_AV1_NUM_REF_FRAMES * sizeof(uint8_t)); + memcpy(out->ref_frame_idx, in->ref_frame_idx, STD_VIDEO_AV1_REFS_PER_FRAME * sizeof(int8_t)); + memcpy(out->reserved1, in->reserved1, 3 * sizeof(uint8_t)); + memcpy(out->delta_frame_id_minus_1, in->delta_frame_id_minus_1, STD_VIDEO_AV1_REFS_PER_FRAME * sizeof(uint32_t)); + out->pTileInfo = convert_StdVideoAV1TileInfo_array_win32_to_host(ctx, (const StdVideoAV1TileInfo32 *)UlongToPtr(in->pTileInfo), 1); + out->pQuantization = UlongToPtr(in->pQuantization); + out->pSegmentation = UlongToPtr(in->pSegmentation); + out->pLoopFilter = UlongToPtr(in->pLoopFilter); + out->pCDEF = UlongToPtr(in->pCDEF); + out->pLoopRestoration = UlongToPtr(in->pLoopRestoration); + out->pGlobalMotion = UlongToPtr(in->pGlobalMotion); + out->pExtensionHeader = UlongToPtr(in->pExtensionHeader); + out->pBufferRemovalTimes = UlongToPtr(in->pBufferRemovalTimes); +} + +static const StdVideoEncodeAV1PictureInfo *convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, uint32_t count) +{ + StdVideoEncodeAV1PictureInfo *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_StdVideoEncodeAV1PictureInfo_win32_to_host(ctx, &in[i], &out[i]); + } + + return out; +} + static void convert_StdVideoEncodeH264SliceHeader_win32_to_host(const StdVideoEncodeH264SliceHeader32 *in, StdVideoEncodeH264SliceHeader *out) { if (!in) return; @@ -13219,55 +13268,6 @@ static const StdVideoEncodeH264PictureInfo *convert_StdVideoEncodeH264PictureInf return out; }

-static void convert_StdVideoEncodeAV1PictureInfo_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, StdVideoEncodeAV1PictureInfo *out) -{ - if (!in) return; - - out->flags = in->flags; - out->frame_type = in->frame_type; - out->frame_presentation_time = in->frame_presentation_time; - out->current_frame_id = in->current_frame_id; - out->order_hint = in->order_hint; - out->primary_ref_frame = in->primary_ref_frame; - out->refresh_frame_flags = in->refresh_frame_flags; - out->coded_denom = in->coded_denom; - out->render_width_minus_1 = in->render_width_minus_1; - out->render_height_minus_1 = in->render_height_minus_1; - out->interpolation_filter = in->interpolation_filter; - out->TxMode = in->TxMode; - out->delta_q_res = in->delta_q_res; - out->delta_lf_res = in->delta_lf_res; - memcpy(out->ref_order_hint, in->ref_order_hint, STD_VIDEO_AV1_NUM_REF_FRAMES * sizeof(uint8_t)); - memcpy(out->ref_frame_idx, in->ref_frame_idx, STD_VIDEO_AV1_REFS_PER_FRAME * sizeof(int8_t)); - memcpy(out->reserved1, in->reserved1, 3 * sizeof(uint8_t)); - memcpy(out->delta_frame_id_minus_1, in->delta_frame_id_minus_1, STD_VIDEO_AV1_REFS_PER_FRAME * sizeof(uint32_t)); - out->pTileInfo = convert_StdVideoAV1TileInfo_array_win32_to_host(ctx, (const StdVideoAV1TileInfo32 *)UlongToPtr(in->pTileInfo), 1); - out->pQuantization = UlongToPtr(in->pQuantization); - out->pSegmentation = UlongToPtr(in->pSegmentation); - out->pLoopFilter = UlongToPtr(in->pLoopFilter); - out->pCDEF = UlongToPtr(in->pCDEF); - out->pLoopRestoration = UlongToPtr(in->pLoopRestoration); - out->pGlobalMotion = UlongToPtr(in->pGlobalMotion); - out->pExtensionHeader = UlongToPtr(in->pExtensionHeader); - out->pBufferRemovalTimes = UlongToPtr(in->pBufferRemovalTimes); -} - -static const StdVideoEncodeAV1PictureInfo *convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(struct conversion_context *ctx, const StdVideoEncodeAV1PictureInfo32 *in, uint32_t count) -{ - StdVideoEncodeAV1PictureInfo *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_StdVideoEncodeAV1PictureInfo_win32_to_host(ctx, &in[i], &out[i]); - } - - return out; -} - static void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeInfoKHR32 *in, VkVideoEncodeInfoKHR *out) { const VkBaseInStructure32 *in_header; @@ -13291,27 +13291,19 @@ static void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_context { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: - { - VkVideoInlineQueryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoInlineQueryInfoKHR32 *in_ext = (const VkVideoInlineQueryInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; - out_ext->pNext = NULL; - out_ext->queryPool = in_ext->queryPool; - out_ext->firstQuery = in_ext->firstQuery; - out_ext->queryCount = in_ext->queryCount; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR: { - VkVideoEncodeQuantizationMapInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeQuantizationMapInfoKHR32 *in_ext = (const VkVideoEncodeQuantizationMapInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR; + VkVideoEncodeAV1PictureInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1PictureInfoKHR32 *in_ext = (const VkVideoEncodeAV1PictureInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR; out_ext->pNext = NULL; - out_ext->quantizationMap = in_ext->quantizationMap; - out_ext->quantizationMapExtent = in_ext->quantizationMapExtent; + out_ext->predictionMode = in_ext->predictionMode; + out_ext->rateControlGroup = in_ext->rateControlGroup; + out_ext->constantQIndex = in_ext->constantQIndex; + out_ext->pStdPictureInfo = convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(ctx, (const StdVideoEncodeAV1PictureInfo32 *)UlongToPtr(in_ext->pStdPictureInfo), 1); + memcpy(out_ext->referenceNameSlotIndices, in_ext->referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR * sizeof(int32_t)); + out_ext->primaryReferenceCdfOnly = in_ext->primaryReferenceCdfOnly; + out_ext->generateObuExtensionHeader = in_ext->generateObuExtensionHeader; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -13330,23 +13322,6 @@ static void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR: - { - VkVideoEncodeAV1PictureInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeAV1PictureInfoKHR32 *in_ext = (const VkVideoEncodeAV1PictureInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR; - out_ext->pNext = NULL; - out_ext->predictionMode = in_ext->predictionMode; - out_ext->rateControlGroup = in_ext->rateControlGroup; - out_ext->constantQIndex = in_ext->constantQIndex; - out_ext->pStdPictureInfo = convert_StdVideoEncodeAV1PictureInfo_array_win32_to_host(ctx, (const StdVideoEncodeAV1PictureInfo32 *)UlongToPtr(in_ext->pStdPictureInfo), 1); - memcpy(out_ext->referenceNameSlotIndices, in_ext->referenceNameSlotIndices, VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR * sizeof(int32_t)); - out_ext->primaryReferenceCdfOnly = in_ext->primaryReferenceCdfOnly; - out_ext->generateObuExtensionHeader = in_ext->generateObuExtensionHeader; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR: { VkVideoEncodeIntraRefreshInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -13359,13 +13334,38 @@ static void convert_VkVideoEncodeInfoKHR_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } - default: - FIXME("Unhandled sType %u.\n", in_header->sType); + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR: + { + VkVideoEncodeQuantizationMapInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeQuantizationMapInfoKHR32 *in_ext = (const VkVideoEncodeQuantizationMapInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR; + out_ext->pNext = NULL; + out_ext->quantizationMap = in_ext->quantizationMap; + out_ext->quantizationMapExtent = in_ext->quantizationMapExtent; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; break; } - } -} - + case VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: + { + VkVideoInlineQueryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoInlineQueryInfoKHR32 *in_ext = (const VkVideoInlineQueryInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR; + out_ext->pNext = NULL; + out_ext->queryPool = in_ext->queryPool; + out_ext->firstQuery = in_ext->firstQuery; + out_ext->queryCount = in_ext->queryCount; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } + } +} + static void convert_VkPerTileEndInfoQCOM_win32_to_host(const VkPerTileEndInfoQCOM32 *in, VkPerTileEndInfoQCOM *out) { if (!in) return; @@ -13706,6 +13706,17 @@ static void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_context { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: + { + VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT; + out_ext->pNext = NULL; + out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: { VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -13720,17 +13731,6 @@ static void convert_VkImageMemoryBarrier_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: - { - VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT; - out_ext->pNext = NULL; - out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -13807,25 +13807,25 @@ static void convert_VkBufferMemoryBarrier2_win32_to_host(struct conversion_conte { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: { - VkMemoryBarrierAccessFlags3KHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkMemoryBarrierAccessFlags3KHR32 *in_ext = (const VkMemoryBarrierAccessFlags3KHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR; + VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT; out_ext->pNext = NULL; - out_ext->srcAccessMask3 = in_ext->srcAccessMask3; - out_ext->dstAccessMask3 = in_ext->dstAccessMask3; + out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: { - VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT; + VkMemoryBarrierAccessFlags3KHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkMemoryBarrierAccessFlags3KHR32 *in_ext = (const VkMemoryBarrierAccessFlags3KHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR; out_ext->pNext = NULL; - out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory; + out_ext->srcAccessMask3 = in_ext->srcAccessMask3; + out_ext->dstAccessMask3 = in_ext->dstAccessMask3; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -13877,16 +13877,13 @@ static void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion_contex { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: { - VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT; + VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT; out_ext->pNext = NULL; - out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel; - out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize; - out_ext->sampleLocationsCount = in_ext->sampleLocationsCount; - out_ext->pSampleLocations = UlongToPtr(in_ext->pSampleLocations); + out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -13903,13 +13900,16 @@ static void convert_VkImageMemoryBarrier2_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: { - VkExternalMemoryAcquireUnmodifiedEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkExternalMemoryAcquireUnmodifiedEXT32 *in_ext = (const VkExternalMemoryAcquireUnmodifiedEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT; + VkSampleLocationsInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSampleLocationsInfoEXT32 *in_ext = (const VkSampleLocationsInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT; out_ext->pNext = NULL; - out_ext->acquireUnmodifiedMemory = in_ext->acquireUnmodifiedMemory; + out_ext->sampleLocationsPerPixel = in_ext->sampleLocationsPerPixel; + out_ext->sampleLocationGridSize = in_ext->sampleLocationGridSize; + out_ext->sampleLocationsCount = in_ext->sampleLocationsCount; + out_ext->pSampleLocations = UlongToPtr(in_ext->pSampleLocations); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -13991,6 +13991,18 @@ static void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ct { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: + { + VkTensorDependencyInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkTensorDependencyInfoARM32 *in_ext = (const VkTensorDependencyInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM; + out_ext->pNext = NULL; + out_ext->tensorMemoryBarrierCount = in_ext->tensorMemoryBarrierCount; + out_ext->pTensorMemoryBarriers = convert_VkTensorMemoryBarrierARM_array_win32_to_host(ctx, (const VkTensorMemoryBarrierARM32 *)UlongToPtr(in_ext->pTensorMemoryBarriers), 1); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: { VkTensorMemoryBarrierARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -14008,18 +14020,6 @@ static void convert_VkDependencyInfo_win32_to_host(struct conversion_context *ct out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: - { - VkTensorDependencyInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkTensorDependencyInfoARM32 *in_ext = (const VkTensorDependencyInfoARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM; - out_ext->pNext = NULL; - out_ext->tensorMemoryBarrierCount = in_ext->tensorMemoryBarrierCount; - out_ext->pTensorMemoryBarriers = convert_VkTensorMemoryBarrierARM_array_win32_to_host(ctx, (const VkTensorMemoryBarrierARM32 *)UlongToPtr(in_ext->pTensorMemoryBarriers), 1); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -14140,18 +14140,6 @@ static void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: - { - VkWriteDescriptorSetInlineUniformBlock *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkWriteDescriptorSetInlineUniformBlock32 *in_ext = (const VkWriteDescriptorSetInlineUniformBlock32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK; - out_ext->pNext = NULL; - out_ext->dataSize = in_ext->dataSize; - out_ext->pData = UlongToPtr(in_ext->pData); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: { VkWriteDescriptorSetAccelerationStructureKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -14176,6 +14164,18 @@ static void convert_VkWriteDescriptorSet_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: + { + VkWriteDescriptorSetInlineUniformBlock *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkWriteDescriptorSetInlineUniformBlock32 *in_ext = (const VkWriteDescriptorSetInlineUniformBlock32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK; + out_ext->pNext = NULL; + out_ext->dataSize = in_ext->dataSize; + out_ext->pData = UlongToPtr(in_ext->pData); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV: { VkWriteDescriptorSetPartitionedAccelerationStructureNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -14747,17 +14747,6 @@ static void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct co { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: - { - VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; - out_ext->pNext = NULL; - out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: { VkAccelerationStructureMotionInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -14770,6 +14759,17 @@ static void convert_VkAccelerationStructureCreateInfoKHR_win32_to_host(struct co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + { + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -14829,13 +14829,14 @@ static void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion_contex { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: { - VkVideoDecodeUsageInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoDecodeUsageInfoKHR32 *in_ext = (const VkVideoDecodeUsageInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR; + VkVideoDecodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoDecodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoDecodeAV1ProfileInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; out_ext->pNext = NULL; - out_ext->videoUsageHints = in_ext->videoUsageHints; + out_ext->stdProfile = in_ext->stdProfile; + out_ext->filmGrainSupport = in_ext->filmGrainSupport; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -14852,38 +14853,35 @@ static void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: { - VkVideoDecodeVP9ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoDecodeVP9ProfileInfoKHR32 *in_ext = (const VkVideoDecodeVP9ProfileInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR; + VkVideoDecodeUsageInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoDecodeUsageInfoKHR32 *in_ext = (const VkVideoDecodeUsageInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR; out_ext->pNext = NULL; - out_ext->stdProfile = in_ext->stdProfile; + out_ext->videoUsageHints = in_ext->videoUsageHints; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: { - VkVideoDecodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoDecodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoDecodeAV1ProfileInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; + VkVideoDecodeVP9ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoDecodeVP9ProfileInfoKHR32 *in_ext = (const VkVideoDecodeVP9ProfileInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR; out_ext->pNext = NULL; out_ext->stdProfile = in_ext->stdProfile; - out_ext->filmGrainSupport = in_ext->filmGrainSupport; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: { - VkVideoEncodeUsageInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeUsageInfoKHR32 *in_ext = (const VkVideoEncodeUsageInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR; + VkVideoEncodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoEncodeAV1ProfileInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; out_ext->pNext = NULL; - out_ext->videoUsageHints = in_ext->videoUsageHints; - out_ext->videoContentHints = in_ext->videoContentHints; - out_ext->tuningMode = in_ext->tuningMode; + out_ext->stdProfile = in_ext->stdProfile; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -14899,13 +14897,15 @@ static void convert_VkVideoProfileInfoKHR_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: { - VkVideoEncodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoEncodeAV1ProfileInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; + VkVideoEncodeUsageInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeUsageInfoKHR32 *in_ext = (const VkVideoEncodeUsageInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR; out_ext->pNext = NULL; - out_ext->stdProfile = in_ext->stdProfile; + out_ext->videoUsageHints = in_ext->videoUsageHints; + out_ext->videoContentHints = in_ext->videoContentHints; + out_ext->tuningMode = in_ext->tuningMode; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -14953,6 +14953,28 @@ static void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context * { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: + { + VkBufferDeviceAddressCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkBufferDeviceAddressCreateInfoEXT32 *in_ext = (const VkBufferDeviceAddressCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->deviceAddress = in_ext->deviceAddress; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + { + VkBufferOpaqueCaptureAddressCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkBufferOpaqueCaptureAddressCreateInfo32 *in_ext = (const VkBufferOpaqueCaptureAddressCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: { VkBufferUsageFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -14986,33 +15008,22 @@ static void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: { - VkBufferOpaqueCaptureAddressCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkBufferOpaqueCaptureAddressCreateInfo32 *in_ext = (const VkBufferOpaqueCaptureAddressCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO; + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->opaqueCaptureAddress = in_ext->opaqueCaptureAddress; + out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: { - VkBufferDeviceAddressCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkBufferDeviceAddressCreateInfoEXT32 *in_ext = (const VkBufferDeviceAddressCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT; - out_ext->pNext = NULL; - out_ext->deviceAddress = in_ext->deviceAddress; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: - { - VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoProfileListInfoKHR32 *in_ext = (const VkVideoProfileListInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; + VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoProfileListInfoKHR32 *in_ext = (const VkVideoProfileListInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; out_ext->pNext = NULL; out_ext->profileCount = in_ext->profileCount; out_ext->pProfiles = convert_VkVideoProfileInfoKHR_array_win32_to_host(ctx, (const VkVideoProfileInfoKHR32 *)UlongToPtr(in_ext->pProfiles), in_ext->profileCount); @@ -15020,17 +15031,6 @@ static void convert_VkBufferCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: - { - VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; - out_ext->pNext = NULL; - out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -15130,39 +15130,41 @@ static void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct convers { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: { - VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkShaderModuleCreateInfo *in_ext = (const VkShaderModuleCreateInfo *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; + VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDebugUtilsObjectNameInfoEXT *in_ext = (const VkDebugUtilsObjectNameInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->codeSize = in_ext->codeSize; - out_ext->pCode = in_ext->pCode; + out_ext->objectType = in_ext->objectType; + out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle); + out_ext->pObjectName = in_ext->pObjectName; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: { - VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkShaderModuleValidationCacheCreateInfoEXT *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT; + VkPipelineRobustnessCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRobustnessCreateInfo *in_ext = (const VkPipelineRobustnessCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO; out_ext->pNext = NULL; - out_ext->validationCache = in_ext->validationCache; + out_ext->storageBuffers = in_ext->storageBuffers; + out_ext->uniformBuffers = in_ext->uniformBuffers; + out_ext->vertexInputs = in_ext->vertexInputs; + out_ext->images = in_ext->images; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: { - VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDebugUtilsObjectNameInfoEXT *in_ext = (const VkDebugUtilsObjectNameInfoEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT; + VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->objectType = in_ext->objectType; - out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle); - out_ext->pObjectName = in_ext->pObjectName; + out_ext->identifierSize = in_ext->identifierSize; + out_ext->pIdentifier = in_ext->pIdentifier; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -15178,28 +15180,26 @@ static void convert_VkPipelineShaderStageCreateInfo_win64_to_host(struct convers out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: { - VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; + VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkShaderModuleCreateInfo *in_ext = (const VkShaderModuleCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; out_ext->pNext = NULL; - out_ext->identifierSize = in_ext->identifierSize; - out_ext->pIdentifier = in_ext->pIdentifier; + out_ext->flags = in_ext->flags; + out_ext->codeSize = in_ext->codeSize; + out_ext->pCode = in_ext->pCode; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: + case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: { - VkPipelineRobustnessCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRobustnessCreateInfo *in_ext = (const VkPipelineRobustnessCreateInfo *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO; + VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkShaderModuleValidationCacheCreateInfoEXT *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->storageBuffers = in_ext->storageBuffers; - out_ext->uniformBuffers = in_ext->uniformBuffers; - out_ext->vertexInputs = in_ext->vertexInputs; - out_ext->images = in_ext->images; + out_ext->validationCache = in_ext->validationCache; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -15315,39 +15315,41 @@ static void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct convers { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: { - VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkShaderModuleCreateInfo32 *in_ext = (const VkShaderModuleCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; + VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDebugUtilsObjectNameInfoEXT32 *in_ext = (const VkDebugUtilsObjectNameInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->codeSize = in_ext->codeSize; - out_ext->pCode = UlongToPtr(in_ext->pCode); + out_ext->objectType = in_ext->objectType; + out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle); + out_ext->pObjectName = UlongToPtr(in_ext->pObjectName); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: { - VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT; + VkPipelineRobustnessCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRobustnessCreateInfo32 *in_ext = (const VkPipelineRobustnessCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO; out_ext->pNext = NULL; - out_ext->validationCache = in_ext->validationCache; + out_ext->storageBuffers = in_ext->storageBuffers; + out_ext->uniformBuffers = in_ext->uniformBuffers; + out_ext->vertexInputs = in_ext->vertexInputs; + out_ext->images = in_ext->images; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: { - VkDebugUtilsObjectNameInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDebugUtilsObjectNameInfoEXT32 *in_ext = (const VkDebugUtilsObjectNameInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT; + VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->objectType = in_ext->objectType; - out_ext->objectHandle = wine_vk_unwrap_handle(in_ext->objectType, in_ext->objectHandle); - out_ext->pObjectName = UlongToPtr(in_ext->pObjectName); + out_ext->identifierSize = in_ext->identifierSize; + out_ext->pIdentifier = UlongToPtr(in_ext->pIdentifier); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -15363,28 +15365,26 @@ static void convert_VkPipelineShaderStageCreateInfo_win32_to_host(struct convers out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: { - VkPipelineShaderStageModuleIdentifierCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *in_ext = (const VkPipelineShaderStageModuleIdentifierCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT; + VkShaderModuleCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkShaderModuleCreateInfo32 *in_ext = (const VkShaderModuleCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; out_ext->pNext = NULL; - out_ext->identifierSize = in_ext->identifierSize; - out_ext->pIdentifier = UlongToPtr(in_ext->pIdentifier); + out_ext->flags = in_ext->flags; + out_ext->codeSize = in_ext->codeSize; + out_ext->pCode = UlongToPtr(in_ext->pCode); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: + case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: { - VkPipelineRobustnessCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRobustnessCreateInfo32 *in_ext = (const VkPipelineRobustnessCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO; + VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->storageBuffers = in_ext->storageBuffers; - out_ext->uniformBuffers = in_ext->uniformBuffers; - out_ext->vertexInputs = in_ext->vertexInputs; - out_ext->images = in_ext->images; + out_ext->validationCache = in_ext->validationCache; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -15438,17 +15438,6 @@ static void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: - { - VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCreateFlags2CreateInfo32 *in_ext = (const VkPipelineCreateFlags2CreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; - out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: { VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -15461,38 +15450,37 @@ static void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: { - VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; + VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; out_ext->pNext = NULL; - out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1); - out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount; - out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount); + out_ext->compilerControlFlags = in_ext->compilerControlFlags; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: { - VkSubpassShadingPipelineCreateInfoHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSubpassShadingPipelineCreateInfoHUAWEI32 *in_ext = (const VkSubpassShadingPipelineCreateInfoHUAWEI32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI; + VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCreateFlags2CreateInfo32 *in_ext = (const VkPipelineCreateFlags2CreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; out_ext->pNext = NULL; - out_ext->renderPass = in_ext->renderPass; - out_ext->subpass = in_ext->subpass; + out_ext->flags = in_ext->flags; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: { - VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; + VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; out_ext->pNext = NULL; - out_ext->compilerControlFlags = in_ext->compilerControlFlags; + out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1); + out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount; + out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -15511,6 +15499,18 @@ static void convert_VkComputePipelineCreateInfo_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: + { + VkSubpassShadingPipelineCreateInfoHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSubpassShadingPipelineCreateInfoHUAWEI32 *in_ext = (const VkSubpassShadingPipelineCreateInfoHUAWEI32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI; + out_ext->pNext = NULL; + out_ext->renderPass = in_ext->renderPass; + out_ext->subpass = in_ext->subpass; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -15724,6 +15724,19 @@ static void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct conversi { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: + { + VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *in_ext = (const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM; + out_ext->pNext = NULL; + out_ext->dimension = in_ext->dimension; + out_ext->zeroCount = in_ext->zeroCount; + out_ext->groupSize = in_ext->groupSize; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM: { VkTensorDescriptionARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -15740,19 +15753,6 @@ static void convert_VkDataGraphPipelineConstantARM_win32_to_host(struct conversi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: - { - VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *in_ext = (const VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM; - out_ext->pNext = NULL; - out_ext->dimension = in_ext->dimension; - out_ext->zeroCount = in_ext->zeroCount; - out_ext->groupSize = in_ext->groupSize; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -15794,19 +15794,6 @@ static void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conver { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: - { - VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; - out_ext->pNext = NULL; - out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1); - out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount; - out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM: { VkDataGraphPipelineCompilerControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -15818,22 +15805,7 @@ static void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conver out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM: - { - VkDataGraphPipelineShaderModuleCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDataGraphPipelineShaderModuleCreateInfoARM32 *in_ext = (const VkDataGraphPipelineShaderModuleCreateInfoARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM; - out_ext->pNext = NULL; - out_ext->module = in_ext->module; - out_ext->pName = UlongToPtr(in_ext->pName); - out_ext->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, (const VkSpecializationInfo32 *)UlongToPtr(in_ext->pSpecializationInfo), 1); - out_ext->constantCount = in_ext->constantCount; - out_ext->pConstants = convert_VkDataGraphPipelineConstantARM_array_win32_to_host(ctx, (const VkDataGraphPipelineConstantARM32 *)UlongToPtr(in_ext->pConstants), in_ext->constantCount); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM: + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM: { VkDataGraphPipelineIdentifierCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); const VkDataGraphPipelineIdentifierCreateInfoARM32 *in_ext = (const VkDataGraphPipelineIdentifierCreateInfoARM32 *)in_header; @@ -15845,6 +15817,21 @@ static void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM: + { + VkDataGraphPipelineShaderModuleCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDataGraphPipelineShaderModuleCreateInfoARM32 *in_ext = (const VkDataGraphPipelineShaderModuleCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM; + out_ext->pNext = NULL; + out_ext->module = in_ext->module; + out_ext->pName = UlongToPtr(in_ext->pName); + out_ext->pSpecializationInfo = convert_VkSpecializationInfo_array_win32_to_host(ctx, (const VkSpecializationInfo32 *)UlongToPtr(in_ext->pSpecializationInfo), 1); + out_ext->constantCount = in_ext->constantCount; + out_ext->pConstants = convert_VkDataGraphPipelineConstantARM_array_win32_to_host(ctx, (const VkDataGraphPipelineConstantARM32 *)UlongToPtr(in_ext->pConstants), in_ext->constantCount); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: { VkDataGraphProcessingEngineCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -15857,6 +15844,19 @@ static void convert_VkDataGraphPipelineCreateInfoARM_win32_to_host(struct conver out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + { + VkPipelineCreationFeedbackCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCreationFeedbackCreateInfo32 *in_ext = (const VkPipelineCreationFeedbackCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->pPipelineCreationFeedback = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineCreationFeedback), 1); + out_ext->pipelineStageCreationFeedbackCount = in_ext->pipelineStageCreationFeedbackCount; + out_ext->pPipelineStageCreationFeedbacks = convert_VkPipelineCreationFeedback_array_win32_to_host(ctx, (VkPipelineCreationFeedback32 *)UlongToPtr(in_ext->pPipelineStageCreationFeedbacks), in_ext->pipelineStageCreationFeedbackCount); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -15892,6 +15892,15 @@ static void convert_VkDataGraphPipelineCreateInfoARM_host_to_win32(const VkDataG { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: + { + VkDataGraphProcessingEngineCreateInfoARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM); + const VkDataGraphProcessingEngineCreateInfoARM *in_ext = (const VkDataGraphProcessingEngineCreateInfoARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM; + out_ext->pProcessingEngines = PtrToUlong(in_ext->pProcessingEngines); + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: { VkPipelineCreationFeedbackCreateInfo32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO); @@ -15902,15 +15911,6 @@ static void convert_VkDataGraphPipelineCreateInfoARM_host_to_win32(const VkDataG out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: - { - VkDataGraphProcessingEngineCreateInfoARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM); - const VkDataGraphProcessingEngineCreateInfoARM *in_ext = (const VkDataGraphProcessingEngineCreateInfoARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM; - out_ext->pProcessingEngines = PtrToUlong(in_ext->pProcessingEngines); - out_header = (void *)out_ext; - break; - } default: break; } @@ -15999,6 +15999,18 @@ static void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conversion_c { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: + { + VkDataGraphProcessingEngineCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDataGraphProcessingEngineCreateInfoARM32 *in_ext = (const VkDataGraphProcessingEngineCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM; + out_ext->pNext = NULL; + out_ext->processingEngineCount = in_ext->processingEngineCount; + out_ext->pProcessingEngines = UlongToPtr(in_ext->pProcessingEngines); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: { VkDescriptorPoolInlineUniformBlockCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -16022,18 +16034,6 @@ static void convert_VkDescriptorPoolCreateInfo_win32_to_host(struct conversion_c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: - { - VkDataGraphProcessingEngineCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDataGraphProcessingEngineCreateInfoARM32 *in_ext = (const VkDataGraphProcessingEngineCreateInfoARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM; - out_ext->pNext = NULL; - out_ext->processingEngineCount = in_ext->processingEngineCount; - out_ext->pProcessingEngines = UlongToPtr(in_ext->pProcessingEngines); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -16205,198 +16205,189 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context * { case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: + case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: { - VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; + VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDeviceDiagnosticsConfigCreateInfoNV *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV; out_ext->pNext = NULL; - out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; + out_ext->flags = in_ext->flags; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: { - VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; + VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDeviceGroupDeviceCreateInfo *in_ext = (const VkDeviceGroupDeviceCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO; out_ext->pNext = NULL; - out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute; - out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines; - out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay; + out_ext->physicalDeviceCount = in_ext->physicalDeviceCount; + out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win64_to_host(ctx, in_ext->pPhysicalDevices, in_ext->physicalDeviceCount); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: { - VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDevicePrivateDataCreateInfo *in_ext = (const VkDevicePrivateDataCreateInfo *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO; + VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDeviceMemoryOverallocationCreateInfoAMD *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD; out_ext->pNext = NULL; - out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount; + out_ext->overallocationBehavior = in_ext->overallocationBehavior; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: { - VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; + VkDevicePipelineBinaryInternalCacheControlKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDevicePipelineBinaryInternalCacheControlKHR *in_ext = (const VkDevicePipelineBinaryInternalCacheControlKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; out_ext->pNext = NULL; - out_ext->privateData = in_ext->privateData; + out_ext->disableInternalCache = in_ext->disableInternalCache; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: { - VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; + VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDevicePrivateDataCreateInfo *in_ext = (const VkDevicePrivateDataCreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO; out_ext->pNext = NULL; - out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure; + out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: { - VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFeatures2 *in_ext = (const VkPhysicalDeviceFeatures2 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; + VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDeviceQueueShaderCoreControlCreateInfoARM *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; out_ext->pNext = NULL; - out_ext->features = in_ext->features; + out_ext->shaderCoreCount = in_ext->shaderCoreCount; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR: { - VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; + VkPerformanceQueryReservationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPerformanceQueryReservationInfoKHR *in_ext = (const VkPerformanceQueryReservationInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR; out_ext->pNext = NULL; - out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; - out_ext->variablePointers = in_ext->variablePointers; + out_ext->maxPerformanceQueriesPerPool = in_ext->maxPerformanceQueriesPerPool; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: { - VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; + VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; out_ext->pNext = NULL; - out_ext->multiview = in_ext->multiview; - out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; - out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; + out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; + out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; + out_ext->storagePushConstant16 = in_ext->storagePushConstant16; + out_ext->storageInputOutput16 = in_ext->storageInputOutput16; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: { - VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDeviceGroupDeviceCreateInfo *in_ext = (const VkDeviceGroupDeviceCreateInfo *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO; + VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->physicalDeviceCount = in_ext->physicalDeviceCount; - out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win64_to_host(ctx, in_ext->pPhysicalDevices, in_ext->physicalDeviceCount); + out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4; + out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: { - VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; + VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; out_ext->pNext = NULL; - out_ext->presentId = in_ext->presentId; + out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; + out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; + out_ext->storagePushConstant8 = in_ext->storagePushConstant8; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: { - VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentId2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; + VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->presentId2 = in_ext->presentId2; + out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: { - VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; + VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->presentWait = in_ext->presentWait; + out_ext->accelerationStructure = in_ext->accelerationStructure; + out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay; + out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild; + out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands; + out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: { - VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentWait2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; + VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->presentWait2 = in_ext->presentWait2; + out_ext->reportAddressBinding = in_ext->reportAddressBinding; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: { - VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; + VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAntiLagFeaturesAMD *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; out_ext->pNext = NULL; - out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; - out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; - out_ext->storagePushConstant16 = in_ext->storagePushConstant16; - out_ext->storageInputOutput16 = in_ext->storageInputOutput16; + out_ext->antiLag = in_ext->antiLag; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: { - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; + VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; + out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: { - VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; - out_ext->pNext = NULL; - out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: - { - VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; + VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->protectedMemory = in_ext->protectedMemory; + out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -16412,1631 +16403,1529 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context * out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: { - VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; + VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->multiDraw = in_ext->multiDraw; + out_ext->borderColorSwizzle = in_ext->borderColorSwizzle; + out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: { - VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; + VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; out_ext->pNext = NULL; - out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; - out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; + out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; + out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; + out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: { - VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; + VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->maintenance4 = in_ext->maintenance4; + out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; + out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; + out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: { - VkPhysicalDeviceMaintenance5Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance5Features *in_ext = (const VkPhysicalDeviceMaintenance5Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; + VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->maintenance5 = in_ext->maintenance5; + out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: { - VkPhysicalDeviceMaintenance6Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance6Features *in_ext = (const VkPhysicalDeviceMaintenance6Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; + VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI; out_ext->pNext = NULL; - out_ext->maintenance6 = in_ext->maintenance6; + out_ext->clustercullingShader = in_ext->clustercullingShader; + out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: { - VkPhysicalDeviceMaintenance8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance8FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; + VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; out_ext->pNext = NULL; - out_ext->maintenance8 = in_ext->maintenance8; + out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: { - VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance9FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; + VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->maintenance9 = in_ext->maintenance9; + out_ext->colorWriteEnable = in_ext->colorWriteEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: { - VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; + VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; + out_ext->commandBufferInheritance = in_ext->commandBufferInheritance; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: { - VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; + VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->shaderFloat16 = in_ext->shaderFloat16; - out_ext->shaderInt8 = in_ext->shaderInt8; + out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads; + out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: { - VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; + VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->hostQueryReset = in_ext->hostQueryReset; + out_ext->conditionalRendering = in_ext->conditionalRendering; + out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: { - VkPhysicalDeviceGlobalPriorityQueryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceGlobalPriorityQueryFeatures *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; + VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; out_ext->pNext = NULL; - out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; + out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope; + out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions; + out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions; + out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions; + out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations; + out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing; + out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: { - VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; + VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; - out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; - out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; - out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; - out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; - out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; - out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; - out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; - out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; - out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; - out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; - out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; - out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; - out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; - out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; - out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; - out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; - out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; - out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; - out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; + out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; + out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: { - VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; + VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; out_ext->pNext = NULL; - out_ext->timelineSemaphore = in_ext->timelineSemaphore; + out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; + out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: { - VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; + VkPhysicalDeviceCooperativeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeVectorFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; - out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; - out_ext->storagePushConstant8 = in_ext->storagePushConstant8; + out_ext->cooperativeVector = in_ext->cooperativeVector; + out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: { - VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; + VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; out_ext->pNext = NULL; - out_ext->conditionalRendering = in_ext->conditionalRendering; - out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering; + out_ext->indirectCopy = in_ext->indirectCopy; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: { - VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; + VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; - out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; - out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; + out_ext->cornerSampledImage = in_ext->cornerSampledImage; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: { - VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; + VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; - out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; + out_ext->coverageReductionMode = in_ext->coverageReductionMode; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: { - VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; + VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCubicClampFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics; - out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd; - out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics; - out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd; - out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics; - out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd; - out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics; - out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd; - out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics; - out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd; - out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics; - out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd; + out_ext->cubicRangeClamp = in_ext->cubicRangeClamp; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: { - VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; - out_ext->pNext = NULL; - out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics; - out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd; - out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax; - out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax; - out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax; - out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics; - out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd; - out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax; - out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax; - out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax; - out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax; - out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax; + VkPhysicalDeviceCubicWeightsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCubicWeightsFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; + out_ext->pNext = NULL; + out_ext->selectableCubicWeights = in_ext->selectableCubicWeights; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: { - VkPhysicalDeviceVertexAttributeDivisorFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVertexAttributeDivisorFeatures *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; + VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; - out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; + out_ext->customBorderColors = in_ext->customBorderColors; + out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: { - VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; + VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDataGraphFeaturesARM *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent; + out_ext->dataGraph = in_ext->dataGraph; + out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind; + out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants; + out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer; + out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: { - VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; + VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; out_ext->pNext = NULL; - out_ext->transformFeedback = in_ext->transformFeedback; - out_ext->geometryStreams = in_ext->geometryStreams; + out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; + VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthBiasControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->representativeFragmentTest = in_ext->representativeFragmentTest; + out_ext->depthBiasControl = in_ext->depthBiasControl; + out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation; + out_ext->floatRepresentation = in_ext->floatRepresentation; + out_ext->depthBiasExact = in_ext->depthBiasExact; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; + VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClampControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->exclusiveScissor = in_ext->exclusiveScissor; + out_ext->depthClampControl = in_ext->depthClampControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: { - VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; + VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->cornerSampledImage = in_ext->cornerSampledImage; + out_ext->depthClampZeroOne = in_ext->depthClampZeroOne; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; + VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads; - out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear; + out_ext->depthClipControl = in_ext->depthClipControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: { - VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; + VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->imageFootprint = in_ext->imageFootprint; + out_ext->depthClipEnable = in_ext->depthClipEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: { - VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; + VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing; + out_ext->descriptorBuffer = in_ext->descriptorBuffer; + out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay; + out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored; + out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: { - VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; + VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->indirectCopy = in_ext->indirectCopy; + out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: { - VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; + VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; out_ext->pNext = NULL; - out_ext->memoryDecompression = in_ext->memoryDecompression; + out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; + out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; + out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; + out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; + out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; + out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; + out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; + out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; + out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; + out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; + out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; + out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; + out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; + out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; + out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; + out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; + out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; + out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; + out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; + out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: { - VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; + VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shadingRateImage = in_ext->shadingRateImage; - out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder; + out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: { - VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; + VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; out_ext->pNext = NULL; - out_ext->invocationMask = in_ext->invocationMask; + out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: { - VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; + VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->taskShader = in_ext->taskShader; - out_ext->meshShader = in_ext->meshShader; + out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute; + out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines; + out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: { - VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->taskShader = in_ext->taskShader; - out_ext->meshShader = in_ext->meshShader; - out_ext->multiviewMeshShader = in_ext->multiviewMeshShader; - out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader; - out_ext->meshShaderQueries = in_ext->meshShaderQueries; + out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; + out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: { - VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; out_ext->pNext = NULL; - out_ext->accelerationStructure = in_ext->accelerationStructure; - out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay; - out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild; - out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands; - out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind; + out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: { - VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; + VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; out_ext->pNext = NULL; - out_ext->rayTracingPipeline = in_ext->rayTracingPipeline; - out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay; - out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed; - out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect; - out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling; + out_ext->diagnosticsConfig = in_ext->diagnosticsConfig; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: { - VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; + VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; out_ext->pNext = NULL; - out_ext->rayQuery = in_ext->rayQuery; + out_ext->dynamicRendering = in_ext->dynamicRendering; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: { - VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; + VkPhysicalDeviceDynamicRenderingLocalReadFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; out_ext->pNext = NULL; - out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1; - out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2; + out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: { - VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDeviceMemoryOverallocationCreateInfoAMD *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD; + VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->overallocationBehavior = in_ext->overallocationBehavior; + out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: { - VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; + VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->fragmentDensityMap = in_ext->fragmentDensityMap; - out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic; - out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages; + out_ext->exclusiveScissor = in_ext->exclusiveScissor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: { - VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred; + out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2; + out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp; + out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: { - VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT; + VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset; + out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin; + out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable; + out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode; + out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples; + out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask; + out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable; + out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable; + out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable; + out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable; + out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation; + out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask; + out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream; + out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode; + out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize; + out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable; + out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable; + out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced; + out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode; + out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode; + out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable; + out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne; + out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable; + out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle; + out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable; + out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation; + out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode; + out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable; + out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable; + out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode; + out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable; + out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: { - VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; + out_ext->extendedDynamicState = in_ext->extendedDynamicState; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: { - VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; + VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; + out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: { - VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; + VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->depthClipEnable = in_ext->depthClipEnable; + out_ext->deviceFault = in_ext->deviceFault; + out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: { - VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; + VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFeatures2 *in_ext = (const VkPhysicalDeviceFeatures2 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; out_ext->pNext = NULL; - out_ext->memoryPriority = in_ext->memoryPriority; + out_ext->features = in_ext->features; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: { - VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; + VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFormatPackFeaturesARM *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory; + out_ext->formatPack = in_ext->formatPack; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: { - VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; + VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; - out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; - out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; + out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: { - VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; + VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; - out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; - out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; + out_ext->fragmentDensityMap = in_ext->fragmentDensityMap; + out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic; + out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: { - VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; + VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; out_ext->pNext = NULL; - out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: { - VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; + VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; + out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: { - VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; + VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; - out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; + out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: { - VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; + VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays; + out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock; + out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock; + out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: { - VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; + VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; out_ext->pNext = NULL; - out_ext->presentBarrier = in_ext->presentBarrier; + out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums; + out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates; + out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: { - VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; + VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools; - out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools; + out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate; + out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate; + out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: { - VkPerformanceQueryReservationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPerformanceQueryReservationInfoKHR *in_ext = (const VkPerformanceQueryReservationInfoKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR; + VkPhysicalDeviceFrameBoundaryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFrameBoundaryFeaturesEXT *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->maxPerformanceQueriesPerPool = in_ext->maxPerformanceQueriesPerPool; + out_ext->frameBoundary = in_ext->frameBoundary; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: { - VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; + VkPhysicalDeviceGlobalPriorityQueryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceGlobalPriorityQueryFeatures *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; out_ext->pNext = NULL; - out_ext->coverageReductionMode = in_ext->coverageReductionMode; + out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: { - VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; + VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2; + out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: { - VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; - out_ext->pNext = NULL; - out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock; - out_ext->shaderDeviceClock = in_ext->shaderDeviceClock; + VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHdrVividFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; + out_ext->pNext = NULL; + out_ext->hdrVivid = in_ext->hdrVivid; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: { - VkPhysicalDeviceIndexTypeUint8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceIndexTypeUint8Features *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; + VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHostImageCopyFeatures *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; out_ext->pNext = NULL; - out_ext->indexTypeUint8 = in_ext->indexTypeUint8; + out_ext->hostImageCopy = in_ext->hostImageCopy; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: { - VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; + VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; out_ext->pNext = NULL; - out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins; + out_ext->hostQueryReset = in_ext->hostQueryReset; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: { - VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock; - out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock; - out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock; + out_ext->image2DViewOf3D = in_ext->image2DViewOf3D; + out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: { - VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; + VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; out_ext->pNext = NULL; - out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; + out_ext->imageAlignmentControl = in_ext->imageAlignmentControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: { - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; + VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart; - out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart; + out_ext->imageCompressionControl = in_ext->imageCompressionControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: { - VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; + VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo; + out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: { - VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; + VkPhysicalDeviceImageProcessing2FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageProcessing2FeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; + out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: { - VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; + VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->texelBufferAlignment = in_ext->texelBufferAlignment; + out_ext->textureSampleWeighted = in_ext->textureSampleWeighted; + out_ext->textureBoxFilter = in_ext->textureBoxFilter; + out_ext->textureBlockMatch = in_ext->textureBlockMatch; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: { - VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; + VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; out_ext->pNext = NULL; - out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; - out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; + out_ext->robustImageAccess = in_ext->robustImageAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: { - VkPhysicalDeviceLineRasterizationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLineRasterizationFeatures *in_ext = (const VkPhysicalDeviceLineRasterizationFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; + VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->rectangularLines = in_ext->rectangularLines; - out_ext->bresenhamLines = in_ext->bresenhamLines; - out_ext->smoothLines = in_ext->smoothLines; - out_ext->stippledRectangularLines = in_ext->stippledRectangularLines; - out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines; - out_ext->stippledSmoothLines = in_ext->stippledSmoothLines; + out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: { - VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; + VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; + out_ext->minLod = in_ext->minLod; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: { - VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; + VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; out_ext->pNext = NULL; - out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; - out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; - out_ext->storagePushConstant16 = in_ext->storagePushConstant16; - out_ext->storageInputOutput16 = in_ext->storageInputOutput16; - out_ext->multiview = in_ext->multiview; - out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; - out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; - out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; - out_ext->variablePointers = in_ext->variablePointers; - out_ext->protectedMemory = in_ext->protectedMemory; - out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; - out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; + out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: { - VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; + VkPhysicalDeviceIndexTypeUint8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceIndexTypeUint8Features *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; out_ext->pNext = NULL; - out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge; - out_ext->drawIndirectCount = in_ext->drawIndirectCount; - out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; - out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; - out_ext->storagePushConstant8 = in_ext->storagePushConstant8; - out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; - out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; - out_ext->shaderFloat16 = in_ext->shaderFloat16; - out_ext->shaderInt8 = in_ext->shaderInt8; - out_ext->descriptorIndexing = in_ext->descriptorIndexing; - out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; - out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; - out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; - out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; - out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; - out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; - out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; - out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; - out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; - out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; - out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; - out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; - out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; - out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; - out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; - out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; - out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; - out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; - out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; - out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; - out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax; - out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; - out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; - out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; - out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; - out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; - out_ext->hostQueryReset = in_ext->hostQueryReset; - out_ext->timelineSemaphore = in_ext->timelineSemaphore; - out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; - out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; - out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; - out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; - out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; - out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; - out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex; - out_ext->shaderOutputLayer = in_ext->shaderOutputLayer; - out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId; + out_ext->indexTypeUint8 = in_ext->indexTypeUint8; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: { - VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; + VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + { + VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; out_ext->pNext = NULL; - out_ext->robustImageAccess = in_ext->robustImageAccess; out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; - out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; - out_ext->privateData = in_ext->privateData; - out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; - out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; - out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; - out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; - out_ext->synchronization2 = in_ext->synchronization2; - out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; - out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; - out_ext->dynamicRendering = in_ext->dynamicRendering; - out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; - out_ext->maintenance4 = in_ext->maintenance4; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: { - VkPhysicalDeviceVulkan14Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkan14Features *in_ext = (const VkPhysicalDeviceVulkan14Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; + VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; out_ext->pNext = NULL; - out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; - out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; - out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; - out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; - out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; - out_ext->rectangularLines = in_ext->rectangularLines; - out_ext->bresenhamLines = in_ext->bresenhamLines; - out_ext->smoothLines = in_ext->smoothLines; - out_ext->stippledRectangularLines = in_ext->stippledRectangularLines; - out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines; - out_ext->stippledSmoothLines = in_ext->stippledSmoothLines; - out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; - out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; - out_ext->indexTypeUint8 = in_ext->indexTypeUint8; - out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; - out_ext->maintenance5 = in_ext->maintenance5; - out_ext->maintenance6 = in_ext->maintenance6; - out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; - out_ext->pipelineRobustness = in_ext->pipelineRobustness; - out_ext->hostImageCopy = in_ext->hostImageCopy; - out_ext->pushDescriptor = in_ext->pushDescriptor; + out_ext->invocationMask = in_ext->invocationMask; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: { - VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; + VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory; + out_ext->legacyDithering = in_ext->legacyDithering; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: { - VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; + VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->customBorderColors = in_ext->customBorderColors; - out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat; + out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: { - VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; + VkPhysicalDeviceLineRasterizationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLineRasterizationFeatures *in_ext = (const VkPhysicalDeviceLineRasterizationFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; out_ext->pNext = NULL; - out_ext->borderColorSwizzle = in_ext->borderColorSwizzle; - out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage; + out_ext->rectangularLines = in_ext->rectangularLines; + out_ext->bresenhamLines = in_ext->bresenhamLines; + out_ext->smoothLines = in_ext->smoothLines; + out_ext->stippledRectangularLines = in_ext->stippledRectangularLines; + out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines; + out_ext->stippledSmoothLines = in_ext->stippledSmoothLines; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: { - VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; + VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; out_ext->pNext = NULL; - out_ext->extendedDynamicState = in_ext->extendedDynamicState; + out_ext->linearColorAttachment = in_ext->linearColorAttachment; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: { - VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; + VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; out_ext->pNext = NULL; - out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2; - out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp; - out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints; + out_ext->maintenance4 = in_ext->maintenance4; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: { - VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; + VkPhysicalDeviceMaintenance5Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance5Features *in_ext = (const VkPhysicalDeviceMaintenance5Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; out_ext->pNext = NULL; - out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin; - out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable; - out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode; - out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples; - out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask; - out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable; - out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable; - out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable; - out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable; - out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation; - out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask; - out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream; - out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode; - out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize; - out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable; - out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable; - out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced; - out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode; - out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode; - out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable; - out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne; - out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable; - out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle; - out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable; - out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation; - out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode; - out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable; - out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable; - out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode; - out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable; - out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable; + out_ext->maintenance5 = in_ext->maintenance5; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: { - VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; + VkPhysicalDeviceMaintenance6Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance6Features *in_ext = (const VkPhysicalDeviceMaintenance6Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; out_ext->pNext = NULL; - out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure; + out_ext->maintenance6 = in_ext->maintenance6; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: { - VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; + VkPhysicalDeviceMaintenance8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance8FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->diagnosticsConfig = in_ext->diagnosticsConfig; + out_ext->maintenance8 = in_ext->maintenance8; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: { - VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDeviceDiagnosticsConfigCreateInfoNV *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV; + VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance9FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; + out_ext->maintenance9 = in_ext->maintenance9; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: { - VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; + VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; + out_ext->memoryMapPlaced = in_ext->memoryMapPlaced; + out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced; + out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: { - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; + VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow; + out_ext->memoryDecompression = in_ext->memoryDecompression; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: { - VkPhysicalDeviceRobustness2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRobustness2FeaturesKHR *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; + VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2; - out_ext->robustImageAccess2 = in_ext->robustImageAccess2; - out_ext->nullDescriptor = in_ext->nullDescriptor; + out_ext->memoryPriority = in_ext->memoryPriority; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: { - VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; + VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->robustImageAccess = in_ext->robustImageAccess; + out_ext->taskShader = in_ext->taskShader; + out_ext->meshShader = in_ext->meshShader; + out_ext->multiviewMeshShader = in_ext->multiviewMeshShader; + out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader; + out_ext->meshShaderQueries = in_ext->meshShaderQueries; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: { - VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; + VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; out_ext->pNext = NULL; - out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout; - out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout; - out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess; - out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess; + out_ext->taskShader = in_ext->taskShader; + out_ext->meshShader = in_ext->meshShader; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: { - VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; + VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4; - out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4; + out_ext->multiDraw = in_ext->multiDraw; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: { - VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; + VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->subpassShading = in_ext->subpassShading; + out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { - VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI; + VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; out_ext->pNext = NULL; - out_ext->clustercullingShader = in_ext->clustercullingShader; - out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader; + out_ext->multiview = in_ext->multiview; + out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; + out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: { - VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; + VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics; - out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics; + out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: { - VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; + VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate; - out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate; - out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate; + out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: { - VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; + VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; + out_ext->mutableDescriptorType = in_ext->mutableDescriptorType; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: { - VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; + VkPhysicalDeviceNestedCommandBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums; - out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates; - out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates; + out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer; + out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering; + out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: { - VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; + VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->image2DViewOf3D = in_ext->image2DViewOf3D; - out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D; + out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: { - VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; + VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D; + out_ext->micromap = in_ext->micromap; + out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay; + out_ext->micromapHostCommands = in_ext->micromapHostCommands; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: { - VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; + VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; out_ext->pNext = NULL; - out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState; + out_ext->opticalFlow = in_ext->opticalFlow; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: { - VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; + VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes; + out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: { - VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; + VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->mutableDescriptorType = in_ext->mutableDescriptorType; + out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: { - VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; + VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; out_ext->pNext = NULL; - out_ext->depthClipControl = in_ext->depthClipControl; + out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet; + out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: { - VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; + VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory; + out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools; + out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: { - VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; + VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineBinaryFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; - out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout; + out_ext->pipelineBinaries = in_ext->pipelineBinaries; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: { - VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthClampControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; + VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; out_ext->pNext = NULL; - out_ext->depthClampControl = in_ext->depthClampControl; + out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: { - VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; + VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; out_ext->pNext = NULL; - out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState; + out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: { - VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; + VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction; + out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: { - VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; + VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->colorWriteEnable = in_ext->colorWriteEnable; + out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: { - VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; + VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->synchronization2 = in_ext->synchronization2; + out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: { - VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; + VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts; - out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo; + out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: { - VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceHostImageCopyFeatures *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; + VkPhysicalDevicePipelineProtectedAccessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineProtectedAccessFeatures *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; out_ext->pNext = NULL; - out_ext->hostImageCopy = in_ext->hostImageCopy; + out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: { - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; + VkPhysicalDevicePipelineRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineRobustnessFeatures *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; out_ext->pNext = NULL; - out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery; - out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard; - out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams; + out_ext->pipelineRobustness = in_ext->pipelineRobustness; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: { - VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; + VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; out_ext->pNext = NULL; - out_ext->legacyDithering = in_ext->legacyDithering; + out_ext->presentBarrier = in_ext->presentBarrier; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: { - VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; + VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentId2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled; + out_ext->presentId2 = in_ext->presentId2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: { - VkPhysicalDevicePipelineProtectedAccessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineProtectedAccessFeatures *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; + VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; + out_ext->presentId = in_ext->presentId; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: { - VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->videoMaintenance1 = in_ext->videoMaintenance1; + out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: { - VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; + VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentWait2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9; + out_ext->presentWait2 = in_ext->presentWait2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: { - VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; + VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap; + out_ext->presentWait = in_ext->presentWait; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: { - VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1; + out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart; + out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: { - VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D; + out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery; + out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard; + out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: { - VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; + VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; out_ext->pNext = NULL; - out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats; + out_ext->privateData = in_ext->privateData; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: { - VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; + VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; out_ext->pNext = NULL; - out_ext->provokingVertexLast = in_ext->provokingVertexLast; - out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex; + out_ext->protectedMemory = in_ext->protectedMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: { - VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; + VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh; + out_ext->provokingVertexLast = in_ext->provokingVertexLast; + out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: { - VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; + VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->descriptorBuffer = in_ext->descriptorBuffer; - out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay; - out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored; - out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors; + out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: { - VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; + VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; + out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess; + out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess; + out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: { - VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; + VkPhysicalDeviceRawAccessChainsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRawAccessChainsFeaturesNV *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; out_ext->pNext = NULL; - out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric; + out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: { - VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; + VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur; - out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect; + out_ext->rayQuery = in_ext->rayQuery; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: { - VkPhysicalDeviceRayTracingValidationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingValidationFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingValidationFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; + VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; out_ext->pNext = NULL; - out_ext->rayTracingValidation = in_ext->rayTracingValidation; + out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -18053,931 +17942,1042 @@ static void convert_VkDeviceCreateInfo_win64_to_host(struct conversion_context * out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; + VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler; + out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1; + out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: { - VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; + VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->dynamicRendering = in_ext->dynamicRendering; + out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur; + out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: { - VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; + VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->minLod = in_ext->minLod; + out_ext->rayTracingPipeline = in_ext->rayTracingPipeline; + out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay; + out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect; + out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: { - VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; + VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess; - out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess; - out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess; + out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: { - VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; + VkPhysicalDeviceRayTracingValidationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingValidationFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingValidationFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; out_ext->pNext = NULL; - out_ext->linearColorAttachment = in_ext->linearColorAttachment; + out_ext->rayTracingValidation = in_ext->rayTracingValidation; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: { - VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; out_ext->pNext = NULL; - out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary; + out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: { - VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineBinaryFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; + VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRenderPassStripedFeaturesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->pipelineBinaries = in_ext->pipelineBinaries; + out_ext->renderPassStriped = in_ext->renderPassStriped; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: { - VkDevicePipelineBinaryInternalCacheControlKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDevicePipelineBinaryInternalCacheControlKHR *in_ext = (const VkDevicePipelineBinaryInternalCacheControlKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; + VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; out_ext->pNext = NULL; - out_ext->disableInternalCache = in_ext->disableInternalCache; + out_ext->representativeFragmentTest = in_ext->representativeFragmentTest; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: { - VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; + VkPhysicalDeviceRobustness2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRobustness2FeaturesKHR *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping; + out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2; + out_ext->robustImageAccess2 = in_ext->robustImageAccess2; + out_ext->nullDescriptor = in_ext->nullDescriptor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: { - VkPhysicalDeviceNestedCommandBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; + VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; out_ext->pNext = NULL; - out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer; - out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering; - out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse; + out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: { - VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; + VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; out_ext->pNext = NULL; - out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier; + out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: { - VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; + VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSchedulingControlsFeaturesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->imageCompressionControl = in_ext->imageCompressionControl; + out_ext->schedulingControls = in_ext->schedulingControls; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: { - VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; + VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; out_ext->pNext = NULL; - out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain; + out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: { - VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; + VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback; + out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: { - VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; + VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->micromap = in_ext->micromap; - out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay; - out_ext->micromapHostCommands = in_ext->micromapHostCommands; + out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics; + out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd; + out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax; + out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax; + out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax; + out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics; + out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd; + out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax; + out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax; + out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax; + out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax; + out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: { - VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier; + out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics; + out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd; + out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics; + out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd; + out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics; + out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd; + out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics; + out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd; + out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics; + out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd; + out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics; + out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: { - VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; + VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; out_ext->pNext = NULL; - out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests; + out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; + out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: { - VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; + VkPhysicalDeviceShaderBfloat16FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderBfloat16FeaturesKHR *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap; + out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type; + out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct; + out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: { - VkPhysicalDevicePipelineRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineRobustnessFeatures *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; + VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->pipelineRobustness = in_ext->pipelineRobustness; + out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock; + out_ext->shaderDeviceClock = in_ext->shaderDeviceClock; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: { - VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; + VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->textureSampleWeighted = in_ext->textureSampleWeighted; - out_ext->textureBoxFilter = in_ext->textureBoxFilter; - out_ext->textureBlockMatch = in_ext->textureBlockMatch; + out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: { - VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; + VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; out_ext->pNext = NULL; - out_ext->tileProperties = in_ext->tileProperties; + out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { - VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; + VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; out_ext->pNext = NULL; - out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout; + out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: { - VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; + VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; out_ext->pNext = NULL; - out_ext->reportAddressBinding = in_ext->reportAddressBinding; + out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: { - VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; + VkPhysicalDeviceShaderExpectAssumeFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderExpectAssumeFeatures *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; out_ext->pNext = NULL; - out_ext->opticalFlow = in_ext->opticalFlow; + out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: { - VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; + VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; out_ext->pNext = NULL; - out_ext->deviceFault = in_ext->deviceFault; - out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary; + out_ext->shaderFloat16 = in_ext->shaderFloat16; + out_ext->shaderInt8 = in_ext->shaderInt8; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: { - VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; + VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloat8FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles; + out_ext->shaderFloat8 = in_ext->shaderFloat8; + out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: { - VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; + VkPhysicalDeviceShaderFloatControls2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloatControls2Features *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; out_ext->pNext = NULL; - out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins; + out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: { - VkPhysicalDeviceFrameBoundaryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFrameBoundaryFeaturesEXT *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; + VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->frameBoundary = in_ext->frameBoundary; + out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics; + out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: { - VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; + VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; out_ext->pNext = NULL; - out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments; + out_ext->imageFootprint = in_ext->imageFootprint; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: { - VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; + VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; out_ext->pNext = NULL; - out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1; + out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: { - VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthBiasControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; + VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; out_ext->pNext = NULL; - out_ext->depthBiasControl = in_ext->depthBiasControl; - out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation; - out_ext->floatRepresentation = in_ext->floatRepresentation; - out_ext->depthBiasExact = in_ext->depthBiasExact; + out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: { - VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder; + out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: { - VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; + VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace; + out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: { - VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; + VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports; + out_ext->shaderObject = in_ext->shaderObject; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: { - VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; + VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderQuadControlFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch; + out_ext->shaderQuadControl = in_ext->shaderQuadControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: { - VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM; + VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas; + out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: { - VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; + VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderObject = in_ext->shaderObject; + out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: { - VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderTileImageFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT; + VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess; - out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess; - out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess; + out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: { - VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; out_ext->pNext = NULL; - out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; - out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; + out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: { - VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAntiLagFeaturesAMD *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; + VkPhysicalDeviceShaderSubgroupRotateFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSubgroupRotateFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; out_ext->pNext = NULL; - out_ext->antiLag = in_ext->antiLag; + out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; + out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: { - VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->tileMemoryHeap = in_ext->tileMemoryHeap; + out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: { - VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCubicClampFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; + VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; out_ext->pNext = NULL; - out_ext->cubicRangeClamp = in_ext->cubicRangeClamp; + out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: { - VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; + VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderTileImageFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->ycbcrDegamma = in_ext->ycbcrDegamma; + out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess; + out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess; + out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: { - VkPhysicalDeviceCubicWeightsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCubicWeightsFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; + VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->selectableCubicWeights = in_ext->selectableCubicWeights; + out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: { - VkPhysicalDeviceImageProcessing2FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageProcessing2FeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; + VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2; + out_ext->shadingRateImage = in_ext->shadingRateImage; + out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: { - VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; + VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; out_ext->pNext = NULL; - out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation; + out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; + out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: { - VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; + VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet; - out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout; + out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: { - VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDeviceQueueShaderCoreControlCreateInfoARM *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; + VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; out_ext->pNext = NULL; - out_ext->shaderCoreCount = in_ext->shaderCoreCount; + out_ext->subpassShading = in_ext->subpassShading; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSchedulingControlsFeaturesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; + VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->schedulingControls = in_ext->schedulingControls; + out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: { - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; + VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; out_ext->pNext = NULL; - out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization; + out_ext->synchronization2 = in_ext->synchronization2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: { - VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRenderPassStripedFeaturesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; + VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTensorFeaturesARM *in_ext = (const VkPhysicalDeviceTensorFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->renderPassStriped = in_ext->renderPassStriped; + out_ext->tensorNonPacked = in_ext->tensorNonPacked; + out_ext->shaderTensorAccess = in_ext->shaderTensorAccess; + out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing; + out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing; + out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind; + out_ext->tensors = in_ext->tensors; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: { - VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap; + out_ext->texelBufferAlignment = in_ext->texelBufferAlignment; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: { - VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; + VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; out_ext->pNext = NULL; - out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence; + out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: { - VkPhysicalDeviceShaderSubgroupRotateFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderSubgroupRotateFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; + VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; - out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; + out_ext->tileMemoryHeap = in_ext->tileMemoryHeap; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: { - VkPhysicalDeviceShaderExpectAssumeFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderExpectAssumeFeatures *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; + VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; + out_ext->tileProperties = in_ext->tileProperties; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: { - VkPhysicalDeviceShaderFloatControls2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderFloatControls2Features *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; + VkPhysicalDeviceTileShadingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTileShadingFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; + out_ext->tileShading = in_ext->tileShading; + out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage; + out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments; + out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments; + out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments; + out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments; + out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments; + out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw; + out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch; + out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile; + out_ext->tileShadingApron = in_ext->tileShadingApron; + out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron; + out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps; + out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: { - VkPhysicalDeviceDynamicRenderingLocalReadFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; + VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; out_ext->pNext = NULL; - out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; + out_ext->timelineSemaphore = in_ext->timelineSemaphore; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: { - VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderQuadControlFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; + VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderQuadControl = in_ext->shaderQuadControl; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: - { - VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; - out_ext->pNext = NULL; - out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics; + out_ext->transformFeedback = in_ext->transformFeedback; + out_ext->geometryStreams = in_ext->geometryStreams; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: { - VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; + VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->memoryMapPlaced = in_ext->memoryMapPlaced; - out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced; - out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve; + out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts; + out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: { - VkPhysicalDeviceShaderBfloat16FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderBfloat16FeaturesKHR *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; + VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; out_ext->pNext = NULL; - out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type; - out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct; - out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix; + out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: { - VkPhysicalDeviceRawAccessChainsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRawAccessChainsFeaturesNV *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; + VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; out_ext->pNext = NULL; - out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains; + out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; + out_ext->variablePointers = in_ext->variablePointers; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: { - VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; + VkPhysicalDeviceVertexAttributeDivisorFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexAttributeDivisorFeatures *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; out_ext->pNext = NULL; - out_ext->commandBufferInheritance = in_ext->commandBufferInheritance; + out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; + out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: { - VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; + VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->imageAlignmentControl = in_ext->imageAlignmentControl; + out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: { - VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; + VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites; + out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: { - VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; + VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; + out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: { - VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; + VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope; - out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions; - out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions; - out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions; - out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations; - out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing; - out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads; + out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: { - VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceHdrVividFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; + VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->hdrVivid = in_ext->hdrVivid; + out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: { - VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; + VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness; + out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; + VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->depthClampZeroOne = in_ext->depthClampZeroOne; + out_ext->videoMaintenance1 = in_ext->videoMaintenance1; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceCooperativeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCooperativeVectorFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; + VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; out_ext->pNext = NULL; - out_ext->cooperativeVector = in_ext->cooperativeVector; - out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining; + out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; + out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; + out_ext->storagePushConstant16 = in_ext->storagePushConstant16; + out_ext->storageInputOutput16 = in_ext->storageInputOutput16; + out_ext->multiview = in_ext->multiview; + out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; + out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; + out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; + out_ext->variablePointers = in_ext->variablePointers; + out_ext->protectedMemory = in_ext->protectedMemory; + out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; + out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceTileShadingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTileShadingFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; + VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; out_ext->pNext = NULL; - out_ext->tileShading = in_ext->tileShading; - out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage; - out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments; - out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments; - out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments; - out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments; - out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments; - out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw; - out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch; - out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile; - out_ext->tileShadingApron = in_ext->tileShadingApron; - out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron; - out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps; - out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing; + out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge; + out_ext->drawIndirectCount = in_ext->drawIndirectCount; + out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; + out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; + out_ext->storagePushConstant8 = in_ext->storagePushConstant8; + out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; + out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; + out_ext->shaderFloat16 = in_ext->shaderFloat16; + out_ext->shaderInt8 = in_ext->shaderInt8; + out_ext->descriptorIndexing = in_ext->descriptorIndexing; + out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; + out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; + out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; + out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; + out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; + out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; + out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; + out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; + out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; + out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; + out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; + out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; + out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; + out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; + out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; + out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; + out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; + out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; + out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; + out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; + out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax; + out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; + out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; + out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; + out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; + out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; + out_ext->hostQueryReset = in_ext->hostQueryReset; + out_ext->timelineSemaphore = in_ext->timelineSemaphore; + out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; + out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; + out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; + out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; + out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; + out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; + out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex; + out_ext->shaderOutputLayer = in_ext->shaderOutputLayer; + out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; + VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; out_ext->pNext = NULL; + out_ext->robustImageAccess = in_ext->robustImageAccess; + out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; + out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; + out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; + out_ext->privateData = in_ext->privateData; + out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; + out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; + out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; + out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; + out_ext->synchronization2 = in_ext->synchronization2; + out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; + out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; + out_ext->dynamicRendering = in_ext->dynamicRendering; + out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; + out_ext->maintenance4 = in_ext->maintenance4; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: { - VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFormatPackFeaturesARM *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; + VkPhysicalDeviceVulkan14Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkan14Features *in_ext = (const VkPhysicalDeviceVulkan14Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; out_ext->pNext = NULL; - out_ext->formatPack = in_ext->formatPack; + out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; + out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; + out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; + out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; + out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; + out_ext->rectangularLines = in_ext->rectangularLines; + out_ext->bresenhamLines = in_ext->bresenhamLines; + out_ext->smoothLines = in_ext->smoothLines; + out_ext->stippledRectangularLines = in_ext->stippledRectangularLines; + out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines; + out_ext->stippledSmoothLines = in_ext->stippledSmoothLines; + out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; + out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; + out_ext->indexTypeUint8 = in_ext->indexTypeUint8; + out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; + out_ext->maintenance5 = in_ext->maintenance5; + out_ext->maintenance6 = in_ext->maintenance6; + out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; + out_ext->pipelineRobustness = in_ext->pipelineRobustness; + out_ext->hostImageCopy = in_ext->hostImageCopy; + out_ext->pushDescriptor = in_ext->pushDescriptor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: { - VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTensorFeaturesARM *in_ext = (const VkPhysicalDeviceTensorFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; + VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; out_ext->pNext = NULL; - out_ext->tensorNonPacked = in_ext->tensorNonPacked; - out_ext->shaderTensorAccess = in_ext->shaderTensorAccess; - out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing; - out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing; - out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind; - out_ext->tensors = in_ext->tensors; + out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; + out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; + out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: { - VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; + VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors; + out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout; + out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout; + out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess; + out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: { - VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderFloat8FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; + VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderFloat8 = in_ext->shaderFloat8; - out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix; + out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: { - VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDataGraphFeaturesARM *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; + VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->dataGraph = in_ext->dataGraph; - out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind; - out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants; - out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer; - out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule; + out_ext->ycbcrDegamma = in_ext->ycbcrDegamma; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: { - VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; + VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode; + out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: { - VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; + VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers; + out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + { + VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; + out_ext->pNext = NULL; + out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -19109,198 +19109,189 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * { case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: break; - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: + case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: { - VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; + VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDeviceDiagnosticsConfigCreateInfoNV32 *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV; out_ext->pNext = NULL; - out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; + out_ext->flags = in_ext->flags; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: { - VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; + VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDeviceGroupDeviceCreateInfo32 *in_ext = (const VkDeviceGroupDeviceCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO; out_ext->pNext = NULL; - out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute; - out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines; - out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay; + out_ext->physicalDeviceCount = in_ext->physicalDeviceCount; + out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->pPhysicalDevices), in_ext->physicalDeviceCount); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: { - VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDevicePrivateDataCreateInfo32 *in_ext = (const VkDevicePrivateDataCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO; + VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDeviceMemoryOverallocationCreateInfoAMD32 *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD; out_ext->pNext = NULL; - out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount; + out_ext->overallocationBehavior = in_ext->overallocationBehavior; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: { - VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; + VkDevicePipelineBinaryInternalCacheControlKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDevicePipelineBinaryInternalCacheControlKHR32 *in_ext = (const VkDevicePipelineBinaryInternalCacheControlKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; out_ext->pNext = NULL; - out_ext->privateData = in_ext->privateData; + out_ext->disableInternalCache = in_ext->disableInternalCache; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: { - VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; + VkDevicePrivateDataCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDevicePrivateDataCreateInfo32 *in_ext = (const VkDevicePrivateDataCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO; out_ext->pNext = NULL; - out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure; + out_ext->privateDataSlotRequestCount = in_ext->privateDataSlotRequestCount; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: { - VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFeatures232 *in_ext = (const VkPhysicalDeviceFeatures232 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; + VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDeviceQueueShaderCoreControlCreateInfoARM32 *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; out_ext->pNext = NULL; - out_ext->features = in_ext->features; + out_ext->shaderCoreCount = in_ext->shaderCoreCount; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR: { - VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; + VkPerformanceQueryReservationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPerformanceQueryReservationInfoKHR32 *in_ext = (const VkPerformanceQueryReservationInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR; out_ext->pNext = NULL; - out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; - out_ext->variablePointers = in_ext->variablePointers; + out_ext->maxPerformanceQueriesPerPool = in_ext->maxPerformanceQueriesPerPool; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: { - VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; + VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; out_ext->pNext = NULL; - out_ext->multiview = in_ext->multiview; - out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; - out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; + out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; + out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; + out_ext->storagePushConstant16 = in_ext->storagePushConstant16; + out_ext->storageInputOutput16 = in_ext->storageInputOutput16; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: { - VkDeviceGroupDeviceCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDeviceGroupDeviceCreateInfo32 *in_ext = (const VkDeviceGroupDeviceCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO; + VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->physicalDeviceCount = in_ext->physicalDeviceCount; - out_ext->pPhysicalDevices = convert_VkPhysicalDevice_array_win32_to_host(ctx, (const PTR32 *)UlongToPtr(in_ext->pPhysicalDevices), in_ext->physicalDeviceCount); + out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4; + out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: { - VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; + VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; out_ext->pNext = NULL; - out_ext->presentId = in_ext->presentId; + out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; + out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; + out_ext->storagePushConstant8 = in_ext->storagePushConstant8; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: { - VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentId2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; + VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->presentId2 = in_ext->presentId2; + out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: { - VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; + VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->presentWait = in_ext->presentWait; + out_ext->accelerationStructure = in_ext->accelerationStructure; + out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay; + out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild; + out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands; + out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: { - VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentWait2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; + VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->presentWait2 = in_ext->presentWait2; + out_ext->reportAddressBinding = in_ext->reportAddressBinding; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: - { - VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; - out_ext->pNext = NULL; - out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; - out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; - out_ext->storagePushConstant16 = in_ext->storagePushConstant16; - out_ext->storageInputOutput16 = in_ext->storageInputOutput16; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: { - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; + VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAntiLagFeaturesAMD32 *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; out_ext->pNext = NULL; - out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; + out_ext->antiLag = in_ext->antiLag; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: { - VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; + VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; + out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: { - VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; + VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->protectedMemory = in_ext->protectedMemory; + out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -19316,1631 +19307,1529 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: { - VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; + VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->multiDraw = in_ext->multiDraw; + out_ext->borderColorSwizzle = in_ext->borderColorSwizzle; + out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: { - VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; + VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; out_ext->pNext = NULL; - out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; - out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; + out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; + out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; + out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: { - VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; + VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->maintenance4 = in_ext->maintenance4; + out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; + out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; + out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: { - VkPhysicalDeviceMaintenance5Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance5Features32 *in_ext = (const VkPhysicalDeviceMaintenance5Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; + VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->maintenance5 = in_ext->maintenance5; + out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: { - VkPhysicalDeviceMaintenance6Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance6Features32 *in_ext = (const VkPhysicalDeviceMaintenance6Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; + VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI; out_ext->pNext = NULL; - out_ext->maintenance6 = in_ext->maintenance6; + out_ext->clustercullingShader = in_ext->clustercullingShader; + out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: { - VkPhysicalDeviceMaintenance8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance8FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; + VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; out_ext->pNext = NULL; - out_ext->maintenance8 = in_ext->maintenance8; + out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: { - VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; + VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->maintenance9 = in_ext->maintenance9; + out_ext->colorWriteEnable = in_ext->colorWriteEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: { - VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; + VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; + out_ext->commandBufferInheritance = in_ext->commandBufferInheritance; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: { - VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; + VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->shaderFloat16 = in_ext->shaderFloat16; - out_ext->shaderInt8 = in_ext->shaderInt8; + out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads; + out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: { - VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; + VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->hostQueryReset = in_ext->hostQueryReset; + out_ext->conditionalRendering = in_ext->conditionalRendering; + out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: { - VkPhysicalDeviceGlobalPriorityQueryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; + VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; out_ext->pNext = NULL; - out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; + out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope; + out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions; + out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions; + out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions; + out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations; + out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing; + out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: { - VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; + VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; - out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; - out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; - out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; - out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; - out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; - out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; - out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; - out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; - out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; - out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; - out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; - out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; - out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; - out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; - out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; - out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; - out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; - out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; - out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; + out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; + out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: { - VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; + VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; out_ext->pNext = NULL; - out_ext->timelineSemaphore = in_ext->timelineSemaphore; + out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; + out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: { - VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; + VkPhysicalDeviceCooperativeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; - out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; - out_ext->storagePushConstant8 = in_ext->storagePushConstant8; + out_ext->cooperativeVector = in_ext->cooperativeVector; + out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: { - VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; + VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; out_ext->pNext = NULL; - out_ext->conditionalRendering = in_ext->conditionalRendering; - out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering; + out_ext->indirectCopy = in_ext->indirectCopy; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: { - VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; + VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; - out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; - out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; + out_ext->cornerSampledImage = in_ext->cornerSampledImage; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: { - VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; + VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; - out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; + out_ext->coverageReductionMode = in_ext->coverageReductionMode; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: { - VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; + VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCubicClampFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics; - out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd; - out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics; - out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd; - out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics; - out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd; - out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics; - out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd; - out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics; - out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd; - out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics; - out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd; + out_ext->cubicRangeClamp = in_ext->cubicRangeClamp; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: { - VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; + VkPhysicalDeviceCubicWeightsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics; - out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd; - out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax; - out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax; - out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax; - out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics; - out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd; - out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax; - out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax; - out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax; - out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax; - out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax; + out_ext->selectableCubicWeights = in_ext->selectableCubicWeights; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: { - VkPhysicalDeviceVertexAttributeDivisorFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; + VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; - out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; + out_ext->customBorderColors = in_ext->customBorderColors; + out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: { - VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; + VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDataGraphFeaturesARM32 *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent; + out_ext->dataGraph = in_ext->dataGraph; + out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind; + out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants; + out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer; + out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: { - VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; + VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; out_ext->pNext = NULL; - out_ext->transformFeedback = in_ext->transformFeedback; - out_ext->geometryStreams = in_ext->geometryStreams; + out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; + VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->representativeFragmentTest = in_ext->representativeFragmentTest; + out_ext->depthBiasControl = in_ext->depthBiasControl; + out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation; + out_ext->floatRepresentation = in_ext->floatRepresentation; + out_ext->depthBiasExact = in_ext->depthBiasExact; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; + VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->exclusiveScissor = in_ext->exclusiveScissor; + out_ext->depthClampControl = in_ext->depthClampControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: { - VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; + VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->cornerSampledImage = in_ext->cornerSampledImage; + out_ext->depthClampZeroOne = in_ext->depthClampZeroOne; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; + VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads; - out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear; + out_ext->depthClipControl = in_ext->depthClipControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: { - VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; + VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->imageFootprint = in_ext->imageFootprint; + out_ext->depthClipEnable = in_ext->depthClipEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: { - VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; + VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing; + out_ext->descriptorBuffer = in_ext->descriptorBuffer; + out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay; + out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored; + out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: { - VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; + VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->indirectCopy = in_ext->indirectCopy; + out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: { - VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; + VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; out_ext->pNext = NULL; - out_ext->memoryDecompression = in_ext->memoryDecompression; + out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; + out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; + out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; + out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; + out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; + out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; + out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; + out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; + out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; + out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; + out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; + out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; + out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; + out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; + out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; + out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; + out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; + out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; + out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; + out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: { - VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; + VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shadingRateImage = in_ext->shadingRateImage; - out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder; + out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: { - VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; + VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; out_ext->pNext = NULL; - out_ext->invocationMask = in_ext->invocationMask; + out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: { - VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; + VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->taskShader = in_ext->taskShader; - out_ext->meshShader = in_ext->meshShader; + out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute; + out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines; + out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: { - VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->taskShader = in_ext->taskShader; - out_ext->meshShader = in_ext->meshShader; - out_ext->multiviewMeshShader = in_ext->multiviewMeshShader; - out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader; - out_ext->meshShaderQueries = in_ext->meshShaderQueries; + out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; + out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: { - VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; out_ext->pNext = NULL; - out_ext->accelerationStructure = in_ext->accelerationStructure; - out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay; - out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild; - out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands; - out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind; + out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: { - VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; - out_ext->pNext = NULL; - out_ext->rayTracingPipeline = in_ext->rayTracingPipeline; - out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay; - out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed; - out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect; - out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling; + VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->diagnosticsConfig = in_ext->diagnosticsConfig; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: { - VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; + VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; out_ext->pNext = NULL; - out_ext->rayQuery = in_ext->rayQuery; + out_ext->dynamicRendering = in_ext->dynamicRendering; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: { - VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; + VkPhysicalDeviceDynamicRenderingLocalReadFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; out_ext->pNext = NULL; - out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1; - out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2; + out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: { - VkDeviceMemoryOverallocationCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDeviceMemoryOverallocationCreateInfoAMD32 *in_ext = (const VkDeviceMemoryOverallocationCreateInfoAMD32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD; + VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->overallocationBehavior = in_ext->overallocationBehavior; + out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: { - VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; + VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->fragmentDensityMap = in_ext->fragmentDensityMap; - out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic; - out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages; + out_ext->exclusiveScissor = in_ext->exclusiveScissor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: { - VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred; + out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2; + out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp; + out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: { - VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT; + VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset; + out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin; + out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable; + out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode; + out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples; + out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask; + out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable; + out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable; + out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable; + out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable; + out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation; + out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask; + out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream; + out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode; + out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize; + out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable; + out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable; + out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced; + out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode; + out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode; + out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable; + out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne; + out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable; + out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle; + out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable; + out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation; + out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode; + out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable; + out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable; + out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode; + out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable; + out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: { - VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; + out_ext->extendedDynamicState = in_ext->extendedDynamicState; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: { - VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; + VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; + out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: { - VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; + VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->depthClipEnable = in_ext->depthClipEnable; + out_ext->deviceFault = in_ext->deviceFault; + out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: { - VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; + VkPhysicalDeviceFeatures2 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFeatures232 *in_ext = (const VkPhysicalDeviceFeatures232 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; out_ext->pNext = NULL; - out_ext->memoryPriority = in_ext->memoryPriority; + out_ext->features = in_ext->features; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: { - VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; + VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFormatPackFeaturesARM32 *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory; + out_ext->formatPack = in_ext->formatPack; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: { - VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; + VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; - out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; - out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; + out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: { - VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; + VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; - out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; - out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; + out_ext->fragmentDensityMap = in_ext->fragmentDensityMap; + out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic; + out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: { - VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; + VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; out_ext->pNext = NULL; - out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: { - VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; + VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; + out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: { - VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; + VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; - out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; + out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: { - VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; + VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays; + out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock; + out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock; + out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: { - VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; + VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; out_ext->pNext = NULL; - out_ext->presentBarrier = in_ext->presentBarrier; + out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums; + out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates; + out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: { - VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; + VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools; - out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools; + out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate; + out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate; + out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: { - VkPerformanceQueryReservationInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPerformanceQueryReservationInfoKHR32 *in_ext = (const VkPerformanceQueryReservationInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR; + VkPhysicalDeviceFrameBoundaryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->maxPerformanceQueriesPerPool = in_ext->maxPerformanceQueriesPerPool; + out_ext->frameBoundary = in_ext->frameBoundary; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: { - VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; + VkPhysicalDeviceGlobalPriorityQueryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; out_ext->pNext = NULL; - out_ext->coverageReductionMode = in_ext->coverageReductionMode; + out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: { - VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; + VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2; + out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: { - VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; + VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; out_ext->pNext = NULL; - out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock; - out_ext->shaderDeviceClock = in_ext->shaderDeviceClock; + out_ext->hdrVivid = in_ext->hdrVivid; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: { - VkPhysicalDeviceIndexTypeUint8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceIndexTypeUint8Features32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; + VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHostImageCopyFeatures32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; out_ext->pNext = NULL; - out_ext->indexTypeUint8 = in_ext->indexTypeUint8; + out_ext->hostImageCopy = in_ext->hostImageCopy; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: { - VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; + VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; out_ext->pNext = NULL; - out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins; + out_ext->hostQueryReset = in_ext->hostQueryReset; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: { - VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock; - out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock; - out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock; + out_ext->image2DViewOf3D = in_ext->image2DViewOf3D; + out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: { - VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; + VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; out_ext->pNext = NULL; - out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; + out_ext->imageAlignmentControl = in_ext->imageAlignmentControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: { - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; + VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart; - out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart; + out_ext->imageCompressionControl = in_ext->imageCompressionControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: { - VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; + VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo; + out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: { - VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; + VkPhysicalDeviceImageProcessing2FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; + out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: { - VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; + VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->texelBufferAlignment = in_ext->texelBufferAlignment; + out_ext->textureSampleWeighted = in_ext->textureSampleWeighted; + out_ext->textureBoxFilter = in_ext->textureBoxFilter; + out_ext->textureBlockMatch = in_ext->textureBlockMatch; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: { - VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; + VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; out_ext->pNext = NULL; - out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; - out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; + out_ext->robustImageAccess = in_ext->robustImageAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: { - VkPhysicalDeviceLineRasterizationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLineRasterizationFeatures32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; + VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->rectangularLines = in_ext->rectangularLines; - out_ext->bresenhamLines = in_ext->bresenhamLines; - out_ext->smoothLines = in_ext->smoothLines; - out_ext->stippledRectangularLines = in_ext->stippledRectangularLines; - out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines; - out_ext->stippledSmoothLines = in_ext->stippledSmoothLines; + out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: { - VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; + VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; + out_ext->minLod = in_ext->minLod; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: { - VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; + VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; out_ext->pNext = NULL; - out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; - out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; - out_ext->storagePushConstant16 = in_ext->storagePushConstant16; - out_ext->storageInputOutput16 = in_ext->storageInputOutput16; - out_ext->multiview = in_ext->multiview; - out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; - out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; - out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; - out_ext->variablePointers = in_ext->variablePointers; - out_ext->protectedMemory = in_ext->protectedMemory; - out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; - out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; + out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: { - VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; + VkPhysicalDeviceIndexTypeUint8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceIndexTypeUint8Features32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; out_ext->pNext = NULL; - out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge; - out_ext->drawIndirectCount = in_ext->drawIndirectCount; - out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; - out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; - out_ext->storagePushConstant8 = in_ext->storagePushConstant8; - out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; - out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; - out_ext->shaderFloat16 = in_ext->shaderFloat16; - out_ext->shaderInt8 = in_ext->shaderInt8; - out_ext->descriptorIndexing = in_ext->descriptorIndexing; - out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; - out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; - out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; - out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; - out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; - out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; - out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; - out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; - out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; - out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; - out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; - out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; - out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; - out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; - out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; - out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; - out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; - out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; - out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; - out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; - out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax; - out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; - out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; - out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; - out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; - out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; - out_ext->hostQueryReset = in_ext->hostQueryReset; - out_ext->timelineSemaphore = in_ext->timelineSemaphore; - out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; - out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; - out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; - out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; - out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; - out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; - out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex; - out_ext->shaderOutputLayer = in_ext->shaderOutputLayer; - out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId; + out_ext->indexTypeUint8 = in_ext->indexTypeUint8; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: { - VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; + VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->robustImageAccess = in_ext->robustImageAccess; - out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; - out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; - out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; - out_ext->privateData = in_ext->privateData; - out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; - out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; - out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; - out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; - out_ext->synchronization2 = in_ext->synchronization2; - out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; - out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; - out_ext->dynamicRendering = in_ext->dynamicRendering; - out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; - out_ext->maintenance4 = in_ext->maintenance4; + out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: { - VkPhysicalDeviceVulkan14Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkan14Features32 *in_ext = (const VkPhysicalDeviceVulkan14Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; + VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; out_ext->pNext = NULL; - out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; - out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; - out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; - out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; - out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; - out_ext->rectangularLines = in_ext->rectangularLines; - out_ext->bresenhamLines = in_ext->bresenhamLines; - out_ext->smoothLines = in_ext->smoothLines; - out_ext->stippledRectangularLines = in_ext->stippledRectangularLines; - out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines; - out_ext->stippledSmoothLines = in_ext->stippledSmoothLines; - out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; - out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; - out_ext->indexTypeUint8 = in_ext->indexTypeUint8; - out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; - out_ext->maintenance5 = in_ext->maintenance5; - out_ext->maintenance6 = in_ext->maintenance6; - out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; - out_ext->pipelineRobustness = in_ext->pipelineRobustness; - out_ext->hostImageCopy = in_ext->hostImageCopy; - out_ext->pushDescriptor = in_ext->pushDescriptor; + out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; + out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: { - VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; + VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; out_ext->pNext = NULL; - out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory; + out_ext->invocationMask = in_ext->invocationMask; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: { - VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; + VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->customBorderColors = in_ext->customBorderColors; - out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat; + out_ext->legacyDithering = in_ext->legacyDithering; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: { - VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; + VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->borderColorSwizzle = in_ext->borderColorSwizzle; - out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage; + out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: { - VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; + VkPhysicalDeviceLineRasterizationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLineRasterizationFeatures32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; out_ext->pNext = NULL; - out_ext->extendedDynamicState = in_ext->extendedDynamicState; + out_ext->rectangularLines = in_ext->rectangularLines; + out_ext->bresenhamLines = in_ext->bresenhamLines; + out_ext->smoothLines = in_ext->smoothLines; + out_ext->stippledRectangularLines = in_ext->stippledRectangularLines; + out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines; + out_ext->stippledSmoothLines = in_ext->stippledSmoothLines; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: { - VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; + VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; out_ext->pNext = NULL; - out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2; - out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp; - out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints; + out_ext->linearColorAttachment = in_ext->linearColorAttachment; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: { - VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; + VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; out_ext->pNext = NULL; - out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin; - out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable; - out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode; - out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples; - out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask; - out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable; - out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable; - out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable; - out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable; - out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation; - out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask; - out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream; - out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode; - out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize; - out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable; - out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable; - out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced; - out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode; - out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode; - out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable; - out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne; - out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable; - out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle; - out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable; - out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation; - out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode; - out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable; - out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable; - out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode; - out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable; - out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable; + out_ext->maintenance4 = in_ext->maintenance4; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: { - VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; + VkPhysicalDeviceMaintenance5Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance5Features32 *in_ext = (const VkPhysicalDeviceMaintenance5Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; out_ext->pNext = NULL; - out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure; + out_ext->maintenance5 = in_ext->maintenance5; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: { - VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; + VkPhysicalDeviceMaintenance6Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance6Features32 *in_ext = (const VkPhysicalDeviceMaintenance6Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; out_ext->pNext = NULL; - out_ext->diagnosticsConfig = in_ext->diagnosticsConfig; + out_ext->maintenance6 = in_ext->maintenance6; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: { - VkDeviceDiagnosticsConfigCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDeviceDiagnosticsConfigCreateInfoNV32 *in_ext = (const VkDeviceDiagnosticsConfigCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV; + VkPhysicalDeviceMaintenance8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance8FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; + out_ext->maintenance8 = in_ext->maintenance8; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: { - VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; + VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; + out_ext->maintenance9 = in_ext->maintenance9; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: { - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; + VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow; + out_ext->memoryMapPlaced = in_ext->memoryMapPlaced; + out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced; + out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: { - VkPhysicalDeviceRobustness2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRobustness2FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; + VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; out_ext->pNext = NULL; - out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2; - out_ext->robustImageAccess2 = in_ext->robustImageAccess2; - out_ext->nullDescriptor = in_ext->nullDescriptor; + out_ext->memoryDecompression = in_ext->memoryDecompression; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: { - VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; + VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->robustImageAccess = in_ext->robustImageAccess; + out_ext->memoryPriority = in_ext->memoryPriority; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: { - VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; + VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout; - out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout; - out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess; - out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess; + out_ext->taskShader = in_ext->taskShader; + out_ext->meshShader = in_ext->meshShader; + out_ext->multiviewMeshShader = in_ext->multiviewMeshShader; + out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader; + out_ext->meshShaderQueries = in_ext->meshShaderQueries; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: { - VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; + VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; out_ext->pNext = NULL; - out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4; - out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4; + out_ext->taskShader = in_ext->taskShader; + out_ext->meshShader = in_ext->meshShader; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: { - VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; + VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->subpassShading = in_ext->subpassShading; + out_ext->multiDraw = in_ext->multiDraw; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: { - VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI; + VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->clustercullingShader = in_ext->clustercullingShader; - out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader; + out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { - VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; + VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; out_ext->pNext = NULL; - out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics; - out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics; + out_ext->multiview = in_ext->multiview; + out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; + out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: { - VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; + VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate; - out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate; - out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate; + out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: { - VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; + VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; + out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: { - VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; + VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums; - out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates; - out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates; + out_ext->mutableDescriptorType = in_ext->mutableDescriptorType; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: { - VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; + VkPhysicalDeviceNestedCommandBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->image2DViewOf3D = in_ext->image2DViewOf3D; - out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D; + out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer; + out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering; + out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: { - VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; + VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D; + out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: { - VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; + VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState; + out_ext->micromap = in_ext->micromap; + out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay; + out_ext->micromapHostCommands = in_ext->micromapHostCommands; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: { - VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; + VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; out_ext->pNext = NULL; - out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes; + out_ext->opticalFlow = in_ext->opticalFlow; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: { - VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; + VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->mutableDescriptorType = in_ext->mutableDescriptorType; + out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: { - VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; + VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->depthClipControl = in_ext->depthClipControl; + out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: { - VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; + VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; out_ext->pNext = NULL; - out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory; + out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet; + out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: { - VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; + VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; - out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout; + out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools; + out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: { - VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; + VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->depthClampControl = in_ext->depthClampControl; + out_ext->pipelineBinaries = in_ext->pipelineBinaries; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: { - VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; + VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; out_ext->pNext = NULL; - out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState; + out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: { - VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; + VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; out_ext->pNext = NULL; - out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction; + out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: { - VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; + VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->colorWriteEnable = in_ext->colorWriteEnable; + out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: { - VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; + VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->synchronization2 = in_ext->synchronization2; + out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: { - VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; + VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts; - out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo; + out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: { - VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceHostImageCopyFeatures32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; + VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->hostImageCopy = in_ext->hostImageCopy; + out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: { - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; + VkPhysicalDevicePipelineProtectedAccessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineProtectedAccessFeatures32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; out_ext->pNext = NULL; - out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery; - out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard; - out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams; + out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: { - VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; + VkPhysicalDevicePipelineRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineRobustnessFeatures32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; out_ext->pNext = NULL; - out_ext->legacyDithering = in_ext->legacyDithering; + out_ext->pipelineRobustness = in_ext->pipelineRobustness; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: { - VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; + VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; out_ext->pNext = NULL; - out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled; + out_ext->presentBarrier = in_ext->presentBarrier; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: { - VkPhysicalDevicePipelineProtectedAccessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineProtectedAccessFeatures32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; + VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentId2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; + out_ext->presentId2 = in_ext->presentId2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: { - VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; + VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->videoMaintenance1 = in_ext->videoMaintenance1; + out_ext->presentId = in_ext->presentId; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: { - VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9; + out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: { - VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; + VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentWait2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap; + out_ext->presentWait2 = in_ext->presentWait2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: { - VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; + VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1; + out_ext->presentWait = in_ext->presentWait; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: { - VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D; + out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart; + out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: { - VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats; + out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery; + out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard; + out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: { - VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; + VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; out_ext->pNext = NULL; - out_ext->provokingVertexLast = in_ext->provokingVertexLast; - out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex; + out_ext->privateData = in_ext->privateData; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: { - VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; + VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; out_ext->pNext = NULL; - out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh; + out_ext->protectedMemory = in_ext->protectedMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: { - VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; + VkPhysicalDeviceProvokingVertexFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->descriptorBuffer = in_ext->descriptorBuffer; - out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay; - out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored; - out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors; + out_ext->provokingVertexLast = in_ext->provokingVertexLast; + out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: { - VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; + VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; + out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: { - VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; + VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric; + out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess; + out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess; + out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: { - VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; + VkPhysicalDeviceRawAccessChainsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; out_ext->pNext = NULL; - out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur; - out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect; + out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: { - VkPhysicalDeviceRayTracingValidationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; + VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->rayTracingValidation = in_ext->rayTracingValidation; + out_ext->rayQuery = in_ext->rayQuery; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: + { + VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; + out_ext->pNext = NULL; + out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -20957,777 +20846,748 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; + VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler; + out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1; + out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: { - VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; + VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->dynamicRendering = in_ext->dynamicRendering; + out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur; + out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: { - VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; + VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->minLod = in_ext->minLod; + out_ext->rayTracingPipeline = in_ext->rayTracingPipeline; + out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay; + out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect; + out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: { - VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; + VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess; - out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess; - out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess; + out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: { - VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; + VkPhysicalDeviceRayTracingValidationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; out_ext->pNext = NULL; - out_ext->linearColorAttachment = in_ext->linearColorAttachment; + out_ext->rayTracingValidation = in_ext->rayTracingValidation; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: { - VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; out_ext->pNext = NULL; - out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary; + out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: { - VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; + VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->pipelineBinaries = in_ext->pipelineBinaries; + out_ext->renderPassStriped = in_ext->renderPassStriped; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: { - VkDevicePipelineBinaryInternalCacheControlKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDevicePipelineBinaryInternalCacheControlKHR32 *in_ext = (const VkDevicePipelineBinaryInternalCacheControlKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR; + VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; out_ext->pNext = NULL; - out_ext->disableInternalCache = in_ext->disableInternalCache; + out_ext->representativeFragmentTest = in_ext->representativeFragmentTest; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: { - VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; + VkPhysicalDeviceRobustness2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRobustness2FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping; + out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2; + out_ext->robustImageAccess2 = in_ext->robustImageAccess2; + out_ext->nullDescriptor = in_ext->nullDescriptor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: { - VkPhysicalDeviceNestedCommandBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; + VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; out_ext->pNext = NULL; - out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer; - out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering; - out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse; + out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: { - VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; + VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; out_ext->pNext = NULL; - out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier; + out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: { - VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; + VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->imageCompressionControl = in_ext->imageCompressionControl; + out_ext->schedulingControls = in_ext->schedulingControls; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: { - VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; + VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; out_ext->pNext = NULL; - out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain; + out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: { - VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; + VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback; + out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: { - VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; + VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->micromap = in_ext->micromap; - out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay; - out_ext->micromapHostCommands = in_ext->micromapHostCommands; + out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics; + out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd; + out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax; + out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax; + out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax; + out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics; + out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd; + out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax; + out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax; + out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax; + out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax; + out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: { - VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier; + out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics; + out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd; + out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics; + out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd; + out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics; + out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd; + out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics; + out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd; + out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics; + out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd; + out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics; + out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: { - VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; + VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; out_ext->pNext = NULL; - out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests; + out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; + out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: { - VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; + VkPhysicalDeviceShaderBfloat16FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap; + out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type; + out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct; + out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: { - VkPhysicalDevicePipelineRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineRobustnessFeatures32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; + VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->pipelineRobustness = in_ext->pipelineRobustness; + out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock; + out_ext->shaderDeviceClock = in_ext->shaderDeviceClock; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: { - VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; + VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->textureSampleWeighted = in_ext->textureSampleWeighted; - out_ext->textureBoxFilter = in_ext->textureBoxFilter; - out_ext->textureBlockMatch = in_ext->textureBlockMatch; + out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: { - VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; + VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; out_ext->pNext = NULL; - out_ext->tileProperties = in_ext->tileProperties; + out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { - VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; + VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; out_ext->pNext = NULL; - out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout; + out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: { - VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; + VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; out_ext->pNext = NULL; - out_ext->reportAddressBinding = in_ext->reportAddressBinding; + out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: { - VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; + VkPhysicalDeviceShaderExpectAssumeFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderExpectAssumeFeatures32 *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; out_ext->pNext = NULL; - out_ext->opticalFlow = in_ext->opticalFlow; + out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: { - VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; + VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; out_ext->pNext = NULL; - out_ext->deviceFault = in_ext->deviceFault; - out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary; + out_ext->shaderFloat16 = in_ext->shaderFloat16; + out_ext->shaderInt8 = in_ext->shaderInt8; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: { - VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; + VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles; + out_ext->shaderFloat8 = in_ext->shaderFloat8; + out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: { - VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; + VkPhysicalDeviceShaderFloatControls2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloatControls2Features32 *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; out_ext->pNext = NULL; - out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins; + out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: { - VkPhysicalDeviceFrameBoundaryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; + VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->frameBoundary = in_ext->frameBoundary; + out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics; + out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: { - VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; + VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; out_ext->pNext = NULL; - out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments; + out_ext->imageFootprint = in_ext->imageFootprint; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: { - VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; + VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; out_ext->pNext = NULL; - out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1; + out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: { - VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; + VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; out_ext->pNext = NULL; - out_ext->depthBiasControl = in_ext->depthBiasControl; - out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation; - out_ext->floatRepresentation = in_ext->floatRepresentation; - out_ext->depthBiasExact = in_ext->depthBiasExact; + out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: { - VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder; + out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: { - VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; + VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace; + out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: { - VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; + VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports; + out_ext->shaderObject = in_ext->shaderObject; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: { - VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; + VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch; + out_ext->shaderQuadControl = in_ext->shaderQuadControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: { - VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM; + VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas; + out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: { - VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; + VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderObject = in_ext->shaderObject; + out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: { - VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT; + VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess; - out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess; - out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess; + out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: { - VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; out_ext->pNext = NULL; - out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; - out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; + out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: { - VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAntiLagFeaturesAMD32 *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; + VkPhysicalDeviceShaderSubgroupRotateFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; out_ext->pNext = NULL; - out_ext->antiLag = in_ext->antiLag; + out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; + out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: { - VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->tileMemoryHeap = in_ext->tileMemoryHeap; + out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: { - VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCubicClampFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; + VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; out_ext->pNext = NULL; - out_ext->cubicRangeClamp = in_ext->cubicRangeClamp; + out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: { - VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; + VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->ycbcrDegamma = in_ext->ycbcrDegamma; + out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess; + out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess; + out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: { - VkPhysicalDeviceCubicWeightsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; + VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->selectableCubicWeights = in_ext->selectableCubicWeights; + out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: { - VkPhysicalDeviceImageProcessing2FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; + VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2; + out_ext->shadingRateImage = in_ext->shadingRateImage; + out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: { - VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; + VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; out_ext->pNext = NULL; - out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation; + out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; + out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: { - VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; + VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet; - out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout; + out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: { - VkDeviceQueueShaderCoreControlCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDeviceQueueShaderCoreControlCreateInfoARM32 *in_ext = (const VkDeviceQueueShaderCoreControlCreateInfoARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM; + VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; out_ext->pNext = NULL; - out_ext->shaderCoreCount = in_ext->shaderCoreCount; + out_ext->subpassShading = in_ext->subpassShading; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; + VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->schedulingControls = in_ext->schedulingControls; + out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: { - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; + VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; out_ext->pNext = NULL; - out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization; + out_ext->synchronization2 = in_ext->synchronization2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: { - VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; + VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceTensorFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->renderPassStriped = in_ext->renderPassStriped; + out_ext->tensorNonPacked = in_ext->tensorNonPacked; + out_ext->shaderTensorAccess = in_ext->shaderTensorAccess; + out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing; + out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing; + out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind; + out_ext->tensors = in_ext->tensors; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: { - VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap; + out_ext->texelBufferAlignment = in_ext->texelBufferAlignment; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: { - VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; + VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; out_ext->pNext = NULL; - out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence; + out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: { - VkPhysicalDeviceShaderSubgroupRotateFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; + VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; - out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; + out_ext->tileMemoryHeap = in_ext->tileMemoryHeap; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: { - VkPhysicalDeviceShaderExpectAssumeFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderExpectAssumeFeatures32 *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; + VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; + out_ext->tileProperties = in_ext->tileProperties; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: { - VkPhysicalDeviceShaderFloatControls2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderFloatControls2Features32 *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; + VkPhysicalDeviceTileShadingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTileShadingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: - { - VkPhysicalDeviceDynamicRenderingLocalReadFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; - out_ext->pNext = NULL; - out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: - { - VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; - out_ext->pNext = NULL; - out_ext->shaderQuadControl = in_ext->shaderQuadControl; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: - { - VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; - out_ext->pNext = NULL; - out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: - { - VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; - out_ext->pNext = NULL; - out_ext->memoryMapPlaced = in_ext->memoryMapPlaced; - out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced; - out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: - { - VkPhysicalDeviceShaderBfloat16FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; - out_ext->pNext = NULL; - out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type; - out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct; - out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: - { - VkPhysicalDeviceRawAccessChainsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; - out_ext->pNext = NULL; - out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains; + out_ext->tileShading = in_ext->tileShading; + out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage; + out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments; + out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments; + out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments; + out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments; + out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments; + out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw; + out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch; + out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile; + out_ext->tileShadingApron = in_ext->tileShadingApron; + out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron; + out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps; + out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: { - VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; + VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; out_ext->pNext = NULL; - out_ext->commandBufferInheritance = in_ext->commandBufferInheritance; + out_ext->timelineSemaphore = in_ext->timelineSemaphore; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: { - VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; + VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->imageAlignmentControl = in_ext->imageAlignmentControl; + out_ext->transformFeedback = in_ext->transformFeedback; + out_ext->geometryStreams = in_ext->geometryStreams; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: { - VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; + VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites; + out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts; + out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: { - VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; + VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; out_ext->pNext = NULL; - out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; + out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: { - VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; + VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; out_ext->pNext = NULL; - out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope; - out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions; - out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions; - out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions; - out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations; - out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing; - out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads; + out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; + out_ext->variablePointers = in_ext->variablePointers; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: { - VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; + VkPhysicalDeviceVertexAttributeDivisorFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; out_ext->pNext = NULL; - out_ext->hdrVivid = in_ext->hdrVivid; + out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; + out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -21743,145 +21603,285 @@ static void convert_VkDeviceCreateInfo_win32_to_host(struct conversion_context * out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: { - VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; + VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->depthClampZeroOne = in_ext->depthClampZeroOne; + out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: { - VkPhysicalDeviceCooperativeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; + VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->cooperativeVector = in_ext->cooperativeVector; - out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining; + out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: { - VkPhysicalDeviceTileShadingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTileShadingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; + VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->tileShading = in_ext->tileShading; - out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage; - out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments; - out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments; - out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments; - out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments; - out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments; - out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw; - out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch; - out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile; - out_ext->tileShadingApron = in_ext->tileShadingApron; - out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron; - out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps; - out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing; + out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: { - VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; + VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; out_ext->pNext = NULL; + out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: { - VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFormatPackFeaturesARM32 *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; + VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->formatPack = in_ext->formatPack; + out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceTensorFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; + VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->tensorNonPacked = in_ext->tensorNonPacked; - out_ext->shaderTensorAccess = in_ext->shaderTensorAccess; - out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing; - out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing; - out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind; - out_ext->tensors = in_ext->tensors; + out_ext->videoMaintenance1 = in_ext->videoMaintenance1; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; + VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; out_ext->pNext = NULL; - out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors; + out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; + out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; + out_ext->storagePushConstant16 = in_ext->storagePushConstant16; + out_ext->storageInputOutput16 = in_ext->storageInputOutput16; + out_ext->multiview = in_ext->multiview; + out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; + out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; + out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; + out_ext->variablePointers = in_ext->variablePointers; + out_ext->protectedMemory = in_ext->protectedMemory; + out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; + out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; + VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; out_ext->pNext = NULL; - out_ext->shaderFloat8 = in_ext->shaderFloat8; - out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix; + out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge; + out_ext->drawIndirectCount = in_ext->drawIndirectCount; + out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; + out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; + out_ext->storagePushConstant8 = in_ext->storagePushConstant8; + out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; + out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; + out_ext->shaderFloat16 = in_ext->shaderFloat16; + out_ext->shaderInt8 = in_ext->shaderInt8; + out_ext->descriptorIndexing = in_ext->descriptorIndexing; + out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; + out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; + out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; + out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; + out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; + out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; + out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; + out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; + out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; + out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; + out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; + out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; + out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; + out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; + out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; + out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; + out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; + out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; + out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; + out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; + out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax; + out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; + out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; + out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; + out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; + out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; + out_ext->hostQueryReset = in_ext->hostQueryReset; + out_ext->timelineSemaphore = in_ext->timelineSemaphore; + out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; + out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; + out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; + out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; + out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; + out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; + out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex; + out_ext->shaderOutputLayer = in_ext->shaderOutputLayer; + out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDataGraphFeaturesARM32 *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; + VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; out_ext->pNext = NULL; - out_ext->dataGraph = in_ext->dataGraph; - out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind; - out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants; - out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer; - out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule; + out_ext->robustImageAccess = in_ext->robustImageAccess; + out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; + out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; + out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; + out_ext->privateData = in_ext->privateData; + out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; + out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; + out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; + out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; + out_ext->synchronization2 = in_ext->synchronization2; + out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; + out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; + out_ext->dynamicRendering = in_ext->dynamicRendering; + out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; + out_ext->maintenance4 = in_ext->maintenance4; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: { - VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; + VkPhysicalDeviceVulkan14Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkan14Features32 *in_ext = (const VkPhysicalDeviceVulkan14Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; out_ext->pNext = NULL; - out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode; + out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; + out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; + out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; + out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; + out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; + out_ext->rectangularLines = in_ext->rectangularLines; + out_ext->bresenhamLines = in_ext->bresenhamLines; + out_ext->smoothLines = in_ext->smoothLines; + out_ext->stippledRectangularLines = in_ext->stippledRectangularLines; + out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines; + out_ext->stippledSmoothLines = in_ext->stippledSmoothLines; + out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; + out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; + out_ext->indexTypeUint8 = in_ext->indexTypeUint8; + out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; + out_ext->maintenance5 = in_ext->maintenance5; + out_ext->maintenance6 = in_ext->maintenance6; + out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; + out_ext->pipelineRobustness = in_ext->pipelineRobustness; + out_ext->hostImageCopy = in_ext->hostImageCopy; + out_ext->pushDescriptor = in_ext->pushDescriptor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: { - VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; + VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; out_ext->pNext = NULL; - out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers; + out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; + out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; + out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: + { + VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; + out_ext->pNext = NULL; + out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout; + out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout; + out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess; + out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + { + VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: + { + VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; + out_ext->pNext = NULL; + out_ext->ycbcrDegamma = in_ext->ycbcrDegamma; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: + { + VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: + { + VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + { + VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; + out_ext->pNext = NULL; + out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22092,25 +22092,26 @@ static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: + case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: { - VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCreateFlags2CreateInfo *in_ext = (const VkPipelineCreateFlags2CreateInfo *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; + VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples; + out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: { - VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineBinaryInfoKHR *in_ext = (const VkPipelineBinaryInfoKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; + VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->binaryCount = in_ext->binaryCount; - out_ext->pPipelineBinaries = in_ext->pPipelineBinaries; + out_ext->flags = in_ext->flags; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22129,27 +22130,36 @@ static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: { - VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; + VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineBinaryInfoKHR *in_ext = (const VkPipelineBinaryInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->discardRectangleMode = in_ext->discardRectangleMode; - out_ext->discardRectangleCount = in_ext->discardRectangleCount; - out_ext->pDiscardRectangles = in_ext->pDiscardRectangles; + out_ext->binaryCount = in_ext->binaryCount; + out_ext->pPipelineBinaries = in_ext->pPipelineBinaries; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: { - VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV; + VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; out_ext->pNext = NULL; - out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable; + out_ext->compilerControlFlags = in_ext->compilerControlFlags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: + { + VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCreateFlags2CreateInfo *in_ext = (const VkPipelineCreateFlags2CreateInfo *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22167,25 +22177,40 @@ static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: { - VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCompilerControlCreateInfoAMD *in_ext = (const VkPipelineCompilerControlCreateInfoAMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; + VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineDiscardRectangleStateCreateInfoEXT *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->compilerControlFlags = in_ext->compilerControlFlags; - out_header->pNext = (void *)out_ext; + out_ext->flags = in_ext->flags; + out_ext->discardRectangleMode = in_ext->discardRectangleMode; + out_ext->discardRectangleCount = in_ext->discardRectangleCount; + out_ext->pDiscardRectangles = in_ext->pDiscardRectangles; + out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: { - VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR; + VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE; out_ext->pNext = NULL; - out_ext->libraryCount = in_ext->libraryCount; - out_ext->pLibraries = in_ext->pLibraries; + out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: + { + VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV; + out_ext->pNext = NULL; + out_ext->shadingRateType = in_ext->shadingRateType; + out_ext->shadingRate = in_ext->shadingRate; + memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR)); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22202,15 +22227,14 @@ static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: { - VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV; + VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineLibraryCreateInfoKHR *in_ext = (const VkPipelineLibraryCreateInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR; out_ext->pNext = NULL; - out_ext->shadingRateType = in_ext->shadingRateType; - out_ext->shadingRate = in_ext->shadingRate; - memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR)); + out_ext->libraryCount = in_ext->libraryCount; + out_ext->pLibraries = in_ext->pLibraries; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22230,26 +22254,13 @@ static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: - { - VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkAttachmentSampleCountInfoAMD *in_ext = (const VkAttachmentSampleCountInfoAMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; - out_ext->pNext = NULL; - out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; - out_ext->pColorAttachmentSamples = in_ext->pColorAttachmentSamples; - out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: { - VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkGraphicsPipelineLibraryCreateInfoEXT *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; + VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; + out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22294,17 +22305,6 @@ static void convert_VkGraphicsPipelineCreateInfo_win64_to_host(struct conversion out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: - { - VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE; - out_ext->pNext = NULL; - out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -22499,28 +22499,38 @@ static void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struct conve { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: { - VkPipelineViewportWScalingStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineViewportWScalingStateCreateInfoNV32 *in_ext = (const VkPipelineViewportWScalingStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV; + VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *in_ext = (const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV; out_ext->pNext = NULL; - out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable; - out_ext->viewportCount = in_ext->viewportCount; - out_ext->pViewportWScalings = UlongToPtr(in_ext->pViewportWScalings); + out_ext->sampleOrderType = in_ext->sampleOrderType; + out_ext->customSampleOrderCount = in_ext->customSampleOrderCount; + out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(in_ext->pCustomSampleOrders), in_ext->customSampleOrderCount); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: { - VkPipelineViewportSwizzleStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineViewportSwizzleStateCreateInfoNV32 *in_ext = (const VkPipelineViewportSwizzleStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; + VkPipelineViewportDepthClampControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineViewportDepthClampControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClampControlCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->viewportCount = in_ext->viewportCount; - out_ext->pViewportSwizzles = UlongToPtr(in_ext->pViewportSwizzles); + out_ext->depthClampMode = in_ext->depthClampMode; + out_ext->pDepthClampRange = UlongToPtr(in_ext->pDepthClampRange); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: + { + VkPipelineViewportDepthClipControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineViewportDepthClipControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClipControlCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->negativeOneToOne = in_ext->negativeOneToOne; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22550,38 +22560,28 @@ static void convert_VkPipelineViewportStateCreateInfo_win32_to_host(struct conve out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: - { - VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *in_ext = (const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV; - out_ext->pNext = NULL; - out_ext->sampleOrderType = in_ext->sampleOrderType; - out_ext->customSampleOrderCount = in_ext->customSampleOrderCount; - out_ext->pCustomSampleOrders = convert_VkCoarseSampleOrderCustomNV_array_win32_to_host(ctx, (const VkCoarseSampleOrderCustomNV32 *)UlongToPtr(in_ext->pCustomSampleOrders), in_ext->customSampleOrderCount); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: { - VkPipelineViewportDepthClipControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineViewportDepthClipControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClipControlCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT; + VkPipelineViewportSwizzleStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineViewportSwizzleStateCreateInfoNV32 *in_ext = (const VkPipelineViewportSwizzleStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV; out_ext->pNext = NULL; - out_ext->negativeOneToOne = in_ext->negativeOneToOne; + out_ext->flags = in_ext->flags; + out_ext->viewportCount = in_ext->viewportCount; + out_ext->pViewportSwizzles = UlongToPtr(in_ext->pViewportSwizzles); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: { - VkPipelineViewportDepthClampControlCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineViewportDepthClampControlCreateInfoEXT32 *in_ext = (const VkPipelineViewportDepthClampControlCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT; + VkPipelineViewportWScalingStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineViewportWScalingStateCreateInfoNV32 *in_ext = (const VkPipelineViewportWScalingStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV; out_ext->pNext = NULL; - out_ext->depthClampMode = in_ext->depthClampMode; - out_ext->pDepthClampRange = UlongToPtr(in_ext->pDepthClampRange); + out_ext->viewportWScalingEnable = in_ext->viewportWScalingEnable; + out_ext->viewportCount = in_ext->viewportCount; + out_ext->pViewportWScalings = UlongToPtr(in_ext->pViewportWScalings); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22634,13 +22634,14 @@ static void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: + case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: { - VkPipelineRasterizationStateRasterizationOrderAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRasterizationStateRasterizationOrderAMD32 *in_ext = (const VkPipelineRasterizationStateRasterizationOrderAMD32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; + VkDepthBiasRepresentationInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDepthBiasRepresentationInfoEXT32 *in_ext = (const VkDepthBiasRepresentationInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT; out_ext->pNext = NULL; - out_ext->rasterizationOrder = in_ext->rasterizationOrder; + out_ext->depthBiasRepresentation = in_ext->depthBiasRepresentation; + out_ext->depthBiasExact = in_ext->depthBiasExact; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22658,18 +22659,6 @@ static void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: - { - VkPipelineRasterizationStateStreamCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRasterizationStateStreamCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationStateStreamCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; - out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->rasterizationStream = in_ext->rasterizationStream; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: { VkPipelineRasterizationDepthClipStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -22707,14 +22696,25 @@ static void convert_VkPipelineRasterizationStateCreateInfo_win32_to_host(struct out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: { - VkDepthBiasRepresentationInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDepthBiasRepresentationInfoEXT32 *in_ext = (const VkDepthBiasRepresentationInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT; + VkPipelineRasterizationStateRasterizationOrderAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRasterizationStateRasterizationOrderAMD32 *in_ext = (const VkPipelineRasterizationStateRasterizationOrderAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; out_ext->pNext = NULL; - out_ext->depthBiasRepresentation = in_ext->depthBiasRepresentation; - out_ext->depthBiasExact = in_ext->depthBiasExact; + out_ext->rasterizationOrder = in_ext->rasterizationOrder; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: + { + VkPipelineRasterizationStateStreamCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRasterizationStateStreamCreateInfoEXT32 *in_ext = (const VkPipelineRasterizationStateStreamCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->rasterizationStream = in_ext->rasterizationStream; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -22763,31 +22763,6 @@ static void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(struct co { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: - { - VkPipelineCoverageToColorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCoverageToColorStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageToColorStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV; - out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->coverageToColorEnable = in_ext->coverageToColorEnable; - out_ext->coverageToColorLocation = in_ext->coverageToColorLocation; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: - { - VkPipelineSampleLocationsStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineSampleLocationsStateCreateInfoEXT32 *in_ext = (const VkPipelineSampleLocationsStateCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT; - out_ext->pNext = NULL; - out_ext->sampleLocationsEnable = in_ext->sampleLocationsEnable; - convert_VkSampleLocationsInfoEXT_win32_to_host(&in_ext->sampleLocationsInfo, &out_ext->sampleLocationsInfo); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: { VkPipelineCoverageModulationStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -22815,6 +22790,31 @@ static void convert_VkPipelineMultisampleStateCreateInfo_win32_to_host(struct co out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: + { + VkPipelineCoverageToColorStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCoverageToColorStateCreateInfoNV32 *in_ext = (const VkPipelineCoverageToColorStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->coverageToColorEnable = in_ext->coverageToColorEnable; + out_ext->coverageToColorLocation = in_ext->coverageToColorLocation; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: + { + VkPipelineSampleLocationsStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineSampleLocationsStateCreateInfoEXT32 *in_ext = (const VkPipelineSampleLocationsStateCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->sampleLocationsEnable = in_ext->sampleLocationsEnable; + convert_VkSampleLocationsInfoEXT_win32_to_host(&in_ext->sampleLocationsInfo, &out_ext->sampleLocationsInfo); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -23032,25 +23032,26 @@ static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: + case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: { - VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCreateFlags2CreateInfo32 *in_ext = (const VkPipelineCreateFlags2CreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; + VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; + out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; + out_ext->pColorAttachmentSamples = UlongToPtr(in_ext->pColorAttachmentSamples); + out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: { - VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineBinaryInfoKHR32 *in_ext = (const VkPipelineBinaryInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; + VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkGraphicsPipelineLibraryCreateInfoEXT32 *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->binaryCount = in_ext->binaryCount; - out_ext->pPipelineBinaries = UlongToPtr(in_ext->pPipelineBinaries); + out_ext->flags = in_ext->flags; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -23069,27 +23070,36 @@ static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: { - VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineDiscardRectangleStateCreateInfoEXT32 *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; + VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineBinaryInfoKHR32 *in_ext = (const VkPipelineBinaryInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->discardRectangleMode = in_ext->discardRectangleMode; - out_ext->discardRectangleCount = in_ext->discardRectangleCount; - out_ext->pDiscardRectangles = UlongToPtr(in_ext->pDiscardRectangles); + out_ext->binaryCount = in_ext->binaryCount; + out_ext->pPipelineBinaries = UlongToPtr(in_ext->pPipelineBinaries); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: { - VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV; + VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; out_ext->pNext = NULL; - out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable; + out_ext->compilerControlFlags = in_ext->compilerControlFlags; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: + { + VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCreateFlags2CreateInfo32 *in_ext = (const VkPipelineCreateFlags2CreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -23107,25 +23117,40 @@ static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: { - VkPipelineCompilerControlCreateInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCompilerControlCreateInfoAMD32 *in_ext = (const VkPipelineCompilerControlCreateInfoAMD32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD; + VkPipelineDiscardRectangleStateCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineDiscardRectangleStateCreateInfoEXT32 *in_ext = (const VkPipelineDiscardRectangleStateCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->compilerControlFlags = in_ext->compilerControlFlags; + out_ext->flags = in_ext->flags; + out_ext->discardRectangleMode = in_ext->discardRectangleMode; + out_ext->discardRectangleCount = in_ext->discardRectangleCount; + out_ext->pDiscardRectangles = UlongToPtr(in_ext->pDiscardRectangles); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: { - VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineLibraryCreateInfoKHR32 *in_ext = (const VkPipelineLibraryCreateInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR; + VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32 *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE; out_ext->pNext = NULL; - out_ext->libraryCount = in_ext->libraryCount; - out_ext->pLibraries = UlongToPtr(in_ext->pLibraries); + out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: + { + VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV; + out_ext->pNext = NULL; + out_ext->shadingRateType = in_ext->shadingRateType; + out_ext->shadingRate = in_ext->shadingRate; + memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR)); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -23142,15 +23167,14 @@ static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: { - VkPipelineFragmentShadingRateEnumStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *in_ext = (const VkPipelineFragmentShadingRateEnumStateCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV; + VkPipelineLibraryCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineLibraryCreateInfoKHR32 *in_ext = (const VkPipelineLibraryCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR; out_ext->pNext = NULL; - out_ext->shadingRateType = in_ext->shadingRateType; - out_ext->shadingRate = in_ext->shadingRate; - memcpy(out_ext->combinerOps, in_ext->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR)); + out_ext->libraryCount = in_ext->libraryCount; + out_ext->pLibraries = UlongToPtr(in_ext->pLibraries); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -23170,26 +23194,13 @@ static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: - { - VkAttachmentSampleCountInfoAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkAttachmentSampleCountInfoAMD32 *in_ext = (const VkAttachmentSampleCountInfoAMD32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD; - out_ext->pNext = NULL; - out_ext->colorAttachmentCount = in_ext->colorAttachmentCount; - out_ext->pColorAttachmentSamples = UlongToPtr(in_ext->pColorAttachmentSamples); - out_ext->depthStencilAttachmentSamples = in_ext->depthStencilAttachmentSamples; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: { - VkGraphicsPipelineLibraryCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkGraphicsPipelineLibraryCreateInfoEXT32 *in_ext = (const VkGraphicsPipelineLibraryCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT; + VkPipelineRepresentativeFragmentTestStateCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *in_ext = (const VkPipelineRepresentativeFragmentTestStateCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; + out_ext->representativeFragmentTestEnable = in_ext->representativeFragmentTestEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -23234,17 +23245,6 @@ static void convert_VkGraphicsPipelineCreateInfo_win32_to_host(struct conversion out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: - { - VkPipelineFragmentDensityMapLayeredCreateInfoVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32 *in_ext = (const VkPipelineFragmentDensityMapLayeredCreateInfoVALVE32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE; - out_ext->pNext = NULL; - out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -23358,13 +23358,26 @@ static void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: + case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: { - VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImageSwapchainCreateInfoKHR *in_ext = (const VkImageSwapchainCreateInfoKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR; + VkImageAlignmentControlCreateInfoMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageAlignmentControlCreateInfoMESA *in_ext = (const VkImageAlignmentControlCreateInfoMESA *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; out_ext->pNext = NULL; - out_ext->swapchain = in_ext->swapchain ? vulkan_swapchain_from_handle(in_ext->swapchain)->host.swapchain : 0; + out_ext->maximumRequestedAlignment = in_ext->maximumRequestedAlignment; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: + { + VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageCompressionControlEXT *in_ext = (const VkImageCompressionControlEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount; + out_ext->pFixedRateFlags = in_ext->pFixedRateFlags; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -23392,14 +23405,13 @@ static void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: { - VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoProfileListInfoKHR *in_ext = (const VkVideoProfileListInfoKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; + VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageSwapchainCreateInfoKHR *in_ext = (const VkImageSwapchainCreateInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR; out_ext->pNext = NULL; - out_ext->profileCount = in_ext->profileCount; - out_ext->pProfiles = in_ext->pProfiles; + out_ext->swapchain = in_ext->swapchain ? vulkan_swapchain_from_handle(in_ext->swapchain)->host.swapchain : 0; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -23415,19 +23427,6 @@ static void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: - { - VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImageCompressionControlEXT *in_ext = (const VkImageCompressionControlEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT; - out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount; - out_ext->pFixedRateFlags = in_ext->pFixedRateFlags; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: { VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -23439,13 +23438,14 @@ static void convert_VkImageCreateInfo_win64_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: { - VkImageAlignmentControlCreateInfoMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImageAlignmentControlCreateInfoMESA *in_ext = (const VkImageAlignmentControlCreateInfoMESA *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; + VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoProfileListInfoKHR *in_ext = (const VkVideoProfileListInfoKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; out_ext->pNext = NULL; - out_ext->maximumRequestedAlignment = in_ext->maximumRequestedAlignment; + out_ext->profileCount = in_ext->profileCount; + out_ext->pProfiles = in_ext->pProfiles; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -23507,13 +23507,26 @@ static void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: + case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: { - VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImageSwapchainCreateInfoKHR32 *in_ext = (const VkImageSwapchainCreateInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR; + VkImageAlignmentControlCreateInfoMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageAlignmentControlCreateInfoMESA32 *in_ext = (const VkImageAlignmentControlCreateInfoMESA32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; out_ext->pNext = NULL; - out_ext->swapchain = in_ext->swapchain ? vulkan_swapchain_from_handle(in_ext->swapchain)->host.swapchain : 0; + out_ext->maximumRequestedAlignment = in_ext->maximumRequestedAlignment; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: + { + VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount; + out_ext->pFixedRateFlags = UlongToPtr(in_ext->pFixedRateFlags); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -23541,14 +23554,13 @@ static void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: { - VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoProfileListInfoKHR32 *in_ext = (const VkVideoProfileListInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; + VkImageSwapchainCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageSwapchainCreateInfoKHR32 *in_ext = (const VkImageSwapchainCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR; out_ext->pNext = NULL; - out_ext->profileCount = in_ext->profileCount; - out_ext->pProfiles = convert_VkVideoProfileInfoKHR_array_win32_to_host(ctx, (const VkVideoProfileInfoKHR32 *)UlongToPtr(in_ext->pProfiles), in_ext->profileCount); + out_ext->swapchain = in_ext->swapchain ? vulkan_swapchain_from_handle(in_ext->swapchain)->host.swapchain : 0; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -23564,19 +23576,6 @@ static void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: - { - VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT; - out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount; - out_ext->pFixedRateFlags = UlongToPtr(in_ext->pFixedRateFlags); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: { VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -23588,13 +23587,14 @@ static void convert_VkImageCreateInfo_win32_to_host(struct conversion_context *c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: { - VkImageAlignmentControlCreateInfoMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImageAlignmentControlCreateInfoMESA32 *in_ext = (const VkImageAlignmentControlCreateInfoMESA32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA; + VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoProfileListInfoKHR32 *in_ext = (const VkVideoProfileListInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; out_ext->pNext = NULL; - out_ext->maximumRequestedAlignment = in_ext->maximumRequestedAlignment; + out_ext->profileCount = in_ext->profileCount; + out_ext->pProfiles = convert_VkVideoProfileInfoKHR_array_win32_to_host(ctx, (const VkVideoProfileInfoKHR32 *)UlongToPtr(in_ext->pProfiles), in_ext->profileCount); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -23626,82 +23626,82 @@ static void convert_VkImageViewCreateInfo_win32_to_host(struct conversion_contex { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: { - VkImageViewUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImageViewUsageCreateInfo32 *in_ext = (const VkImageViewUsageCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO; - out_ext->pNext = NULL; - out_ext->usage = in_ext->usage; + VkImageViewASTCDecodeModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageViewASTCDecodeModeEXT32 *in_ext = (const VkImageViewASTCDecodeModeEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT; + out_ext->pNext = NULL; + out_ext->decodeMode = in_ext->decodeMode; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: { - VkImageViewSlicedCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImageViewSlicedCreateInfoEXT32 *in_ext = (const VkImageViewSlicedCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT; + VkImageViewMinLodCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageViewMinLodCreateInfoEXT32 *in_ext = (const VkImageViewMinLodCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->sliceOffset = in_ext->sliceOffset; - out_ext->sliceCount = in_ext->sliceCount; + out_ext->minLod = in_ext->minLod; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: { - VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO; + VkImageViewSampleWeightCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageViewSampleWeightCreateInfoQCOM32 *in_ext = (const VkImageViewSampleWeightCreateInfoQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; out_ext->pNext = NULL; - out_ext->conversion = in_ext->conversion; + out_ext->filterCenter = in_ext->filterCenter; + out_ext->filterSize = in_ext->filterSize; + out_ext->numPhases = in_ext->numPhases; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: + case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: { - VkImageViewASTCDecodeModeEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImageViewASTCDecodeModeEXT32 *in_ext = (const VkImageViewASTCDecodeModeEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT; + VkImageViewSlicedCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageViewSlicedCreateInfoEXT32 *in_ext = (const VkImageViewSlicedCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->decodeMode = in_ext->decodeMode; + out_ext->sliceOffset = in_ext->sliceOffset; + out_ext->sliceCount = in_ext->sliceCount; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: { - VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + VkImageViewUsageCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageViewUsageCreateInfo32 *in_ext = (const VkImageViewUsageCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO; out_ext->pNext = NULL; - out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData); + out_ext->usage = in_ext->usage; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: { - VkImageViewMinLodCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImageViewMinLodCreateInfoEXT32 *in_ext = (const VkImageViewMinLodCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT; + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->minLod = in_ext->minLod; + out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: { - VkImageViewSampleWeightCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImageViewSampleWeightCreateInfoQCOM32 *in_ext = (const VkImageViewSampleWeightCreateInfoQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM; + VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO; out_ext->pNext = NULL; - out_ext->filterCenter = in_ext->filterCenter; - out_ext->filterSize = in_ext->filterSize; - out_ext->numPhases = in_ext->numPhases; + out_ext->conversion = in_ext->conversion; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -23999,14 +23999,29 @@ static void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: { - VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkValidationFlagsEXT *in_ext = (const VkValidationFlagsEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT; + VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDebugUtilsMessengerCreateInfoEXT *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount; - out_ext->pDisabledValidationChecks = in_ext->pDisabledValidationChecks; + out_ext->flags = in_ext->flags; + out_ext->messageSeverity = in_ext->messageSeverity; + out_ext->messageType = in_ext->messageType; + out_ext->pfnUserCallback = in_ext->pfnUserCallback; + out_ext->pUserData = in_ext->pUserData; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + { + VkLayerSettingsCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkLayerSettingsCreateInfoEXT *in_ext = (const VkLayerSettingsCreateInfoEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->settingCount = in_ext->settingCount; + out_ext->pSettings = in_ext->pSettings; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -24025,29 +24040,14 @@ static void convert_VkInstanceCreateInfo_win64_to_host(struct conversion_context out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: - { - VkLayerSettingsCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkLayerSettingsCreateInfoEXT *in_ext = (const VkLayerSettingsCreateInfoEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT; - out_ext->pNext = NULL; - out_ext->settingCount = in_ext->settingCount; - out_ext->pSettings = in_ext->pSettings; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: { - VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDebugUtilsMessengerCreateInfoEXT *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; + VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkValidationFlagsEXT *in_ext = (const VkValidationFlagsEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->messageSeverity = in_ext->messageSeverity; - out_ext->messageType = in_ext->messageType; - out_ext->pfnUserCallback = in_ext->pfnUserCallback; - out_ext->pUserData = in_ext->pUserData; + out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount; + out_ext->pDisabledValidationChecks = in_ext->pDisabledValidationChecks; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -24153,14 +24153,29 @@ static void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: { - VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkValidationFlagsEXT32 *in_ext = (const VkValidationFlagsEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT; + VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkDebugUtilsMessengerCreateInfoEXT32 *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount; - out_ext->pDisabledValidationChecks = UlongToPtr(in_ext->pDisabledValidationChecks); + out_ext->flags = in_ext->flags; + out_ext->messageSeverity = in_ext->messageSeverity; + out_ext->messageType = in_ext->messageType; + out_ext->pfnUserCallback = (PFN_vkDebugUtilsMessengerCallbackEXT)UlongToPtr(in_ext->pfnUserCallback); + out_ext->pUserData = UlongToPtr(in_ext->pUserData); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: + { + VkLayerSettingsCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkLayerSettingsCreateInfoEXT32 *in_ext = (const VkLayerSettingsCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->settingCount = in_ext->settingCount; + out_ext->pSettings = convert_VkLayerSettingEXT_array_win32_to_host(ctx, (const VkLayerSettingEXT32 *)UlongToPtr(in_ext->pSettings), in_ext->settingCount); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -24179,29 +24194,14 @@ static void convert_VkInstanceCreateInfo_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: - { - VkLayerSettingsCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkLayerSettingsCreateInfoEXT32 *in_ext = (const VkLayerSettingsCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT; - out_ext->pNext = NULL; - out_ext->settingCount = in_ext->settingCount; - out_ext->pSettings = convert_VkLayerSettingEXT_array_win32_to_host(ctx, (const VkLayerSettingEXT32 *)UlongToPtr(in_ext->pSettings), in_ext->settingCount); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: { - VkDebugUtilsMessengerCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkDebugUtilsMessengerCreateInfoEXT32 *in_ext = (const VkDebugUtilsMessengerCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; + VkValidationFlagsEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkValidationFlagsEXT32 *in_ext = (const VkValidationFlagsEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->messageSeverity = in_ext->messageSeverity; - out_ext->messageType = in_ext->messageType; - out_ext->pfnUserCallback = (PFN_vkDebugUtilsMessengerCallbackEXT)UlongToPtr(in_ext->pfnUserCallback); - out_ext->pUserData = UlongToPtr(in_ext->pUserData); + out_ext->disabledValidationCheckCount = in_ext->disabledValidationCheckCount; + out_ext->pDisabledValidationChecks = UlongToPtr(in_ext->pDisabledValidationChecks); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -24489,27 +24489,25 @@ static void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: + case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: { - VkVideoProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoProfileInfoKHR32 *in_ext = (const VkVideoProfileInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR; + VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32 *in_ext = (const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR; out_ext->pNext = NULL; - out_ext->videoCodecOperation = in_ext->videoCodecOperation; - out_ext->chromaSubsampling = in_ext->chromaSubsampling; - out_ext->lumaBitDepth = in_ext->lumaBitDepth; - out_ext->chromaBitDepth = in_ext->chromaBitDepth; + out_ext->encodeFeedbackFlags = in_ext->encodeFeedbackFlags; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: { - VkVideoDecodeUsageInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoDecodeUsageInfoKHR32 *in_ext = (const VkVideoDecodeUsageInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR; + VkVideoDecodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoDecodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoDecodeAV1ProfileInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; out_ext->pNext = NULL; - out_ext->videoUsageHints = in_ext->videoUsageHints; + out_ext->stdProfile = in_ext->stdProfile; + out_ext->filmGrainSupport = in_ext->filmGrainSupport; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -24526,6 +24524,17 @@ static void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: + { + VkVideoDecodeUsageInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoDecodeUsageInfoKHR32 *in_ext = (const VkVideoDecodeUsageInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->videoUsageHints = in_ext->videoUsageHints; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: { VkVideoDecodeVP9ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -24537,14 +24546,24 @@ static void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: { - VkVideoDecodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoDecodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoDecodeAV1ProfileInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR; + VkVideoEncodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoEncodeAV1ProfileInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; out_ext->pNext = NULL; out_ext->stdProfile = in_ext->stdProfile; - out_ext->filmGrainSupport = in_ext->filmGrainSupport; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: + { + VkVideoEncodeH264ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeH264ProfileInfoKHR32 *in_ext = (const VkVideoEncodeH264ProfileInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->stdProfileIdc = in_ext->stdProfileIdc; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -24562,35 +24581,16 @@ static void convert_VkQueryPoolCreateInfo_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: { - VkQueryPoolVideoEncodeFeedbackCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32 *in_ext = (const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR; + VkVideoProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoProfileInfoKHR32 *in_ext = (const VkVideoProfileInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR; out_ext->pNext = NULL; - out_ext->encodeFeedbackFlags = in_ext->encodeFeedbackFlags; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: - { - VkVideoEncodeH264ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeH264ProfileInfoKHR32 *in_ext = (const VkVideoEncodeH264ProfileInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR; - out_ext->pNext = NULL; - out_ext->stdProfileIdc = in_ext->stdProfileIdc; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: - { - VkVideoEncodeAV1ProfileInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeAV1ProfileInfoKHR32 *in_ext = (const VkVideoEncodeAV1ProfileInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR; - out_ext->pNext = NULL; - out_ext->stdProfile = in_ext->stdProfile; + out_ext->videoCodecOperation = in_ext->videoCodecOperation; + out_ext->chromaSubsampling = in_ext->chromaSubsampling; + out_ext->lumaBitDepth = in_ext->lumaBitDepth; + out_ext->chromaBitDepth = in_ext->chromaBitDepth; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -24756,17 +24756,6 @@ static void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conve { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: - { - VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineCreateFlags2CreateInfo32 *in_ext = (const VkPipelineCreateFlags2CreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; - out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: { VkPipelineBinaryInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -24779,13 +24768,13 @@ static void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conve out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: { - VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32 *in_ext = (const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV; + VkPipelineCreateFlags2CreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineCreateFlags2CreateInfo32 *in_ext = (const VkPipelineCreateFlags2CreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO; out_ext->pNext = NULL; - out_ext->allowClusterAccelerationStructure = in_ext->allowClusterAccelerationStructure; + out_ext->flags = in_ext->flags; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -24817,6 +24806,17 @@ static void convert_VkRayTracingPipelineCreateInfoKHR_win32_to_host(struct conve out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV: + { + VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32 *in_ext = (const VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV; + out_ext->pNext = NULL; + out_ext->allowClusterAccelerationStructure = in_ext->allowClusterAccelerationStructure; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -25111,18 +25111,13 @@ static void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_conte { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: { - VkRenderPassMultiviewCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRenderPassMultiviewCreateInfo32 *in_ext = (const VkRenderPassMultiviewCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO; + VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->subpassCount = in_ext->subpassCount; - out_ext->pViewMasks = UlongToPtr(in_ext->pViewMasks); - out_ext->dependencyCount = in_ext->dependencyCount; - out_ext->pViewOffsets = UlongToPtr(in_ext->pViewOffsets); - out_ext->correlationMaskCount = in_ext->correlationMaskCount; - out_ext->pCorrelationMasks = UlongToPtr(in_ext->pCorrelationMasks); + out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -25139,24 +25134,18 @@ static void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_conte out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: - { - VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT; - out_ext->pNext = NULL; - out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: { - VkTileMemorySizeInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkTileMemorySizeInfoQCOM32 *in_ext = (const VkTileMemorySizeInfoQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM; + VkRenderPassMultiviewCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderPassMultiviewCreateInfo32 *in_ext = (const VkRenderPassMultiviewCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO; out_ext->pNext = NULL; - out_ext->size = in_ext->size; + out_ext->subpassCount = in_ext->subpassCount; + out_ext->pViewMasks = UlongToPtr(in_ext->pViewMasks); + out_ext->dependencyCount = in_ext->dependencyCount; + out_ext->pViewOffsets = UlongToPtr(in_ext->pViewOffsets); + out_ext->correlationMaskCount = in_ext->correlationMaskCount; + out_ext->pCorrelationMasks = UlongToPtr(in_ext->pCorrelationMasks); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -25173,6 +25162,17 @@ static void convert_VkRenderPassCreateInfo_win32_to_host(struct conversion_conte out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: + { + VkTileMemorySizeInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkTileMemorySizeInfoQCOM32 *in_ext = (const VkTileMemorySizeInfoQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM; + out_ext->pNext = NULL; + out_ext->size = in_ext->size; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -25314,19 +25314,6 @@ static void convert_VkSubpassDescription2_win32_to_host(struct conversion_contex { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: - { - VkSubpassDescriptionDepthStencilResolve *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSubpassDescriptionDepthStencilResolve32 *in_ext = (const VkSubpassDescriptionDepthStencilResolve32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; - out_ext->pNext = NULL; - out_ext->depthResolveMode = in_ext->depthResolveMode; - out_ext->stencilResolveMode = in_ext->stencilResolveMode; - out_ext->pDepthStencilResolveAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pDepthStencilResolveAttachment), 1); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: { VkFragmentShadingRateAttachmentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -25373,6 +25360,19 @@ static void convert_VkSubpassDescription2_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: + { + VkSubpassDescriptionDepthStencilResolve *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSubpassDescriptionDepthStencilResolve32 *in_ext = (const VkSubpassDescriptionDepthStencilResolve32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE; + out_ext->pNext = NULL; + out_ext->depthResolveMode = in_ext->depthResolveMode; + out_ext->stencilResolveMode = in_ext->stencilResolveMode; + out_ext->pDepthStencilResolveAttachment = convert_VkAttachmentReference2_array_win32_to_host(ctx, (const VkAttachmentReference232 *)UlongToPtr(in_ext->pDepthStencilResolveAttachment), 1); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -25490,17 +25490,6 @@ static void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_cont { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: - { - VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT; - out_ext->pNext = NULL; - out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: { VkRenderPassCreationControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -25523,13 +25512,13 @@ static void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_cont out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: { - VkTileMemorySizeInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkTileMemorySizeInfoQCOM32 *in_ext = (const VkTileMemorySizeInfoQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM; + VkRenderPassFragmentDensityMapCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkRenderPassFragmentDensityMapCreateInfoEXT32 *in_ext = (const VkRenderPassFragmentDensityMapCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->size = in_ext->size; + out_ext->fragmentDensityMapAttachment = in_ext->fragmentDensityMapAttachment; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -25546,6 +25535,17 @@ static void convert_VkRenderPassCreateInfo2_win32_to_host(struct conversion_cont out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: + { + VkTileMemorySizeInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkTileMemorySizeInfoQCOM32 *in_ext = (const VkTileMemorySizeInfoQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM; + out_ext->pNext = NULL; + out_ext->size = in_ext->size; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -25583,36 +25583,25 @@ static void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: - { - VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO; - out_ext->pNext = NULL; - out_ext->conversion = in_ext->conversion; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: { - VkSamplerReductionModeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSamplerReductionModeCreateInfo32 *in_ext = (const VkSamplerReductionModeCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO; + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->reductionMode = in_ext->reductionMode; + out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: { - VkSamplerCustomBorderColorCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSamplerCustomBorderColorCreateInfoEXT32 *in_ext = (const VkSamplerCustomBorderColorCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT; + VkSamplerBlockMatchWindowCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSamplerBlockMatchWindowCreateInfoQCOM32 *in_ext = (const VkSamplerBlockMatchWindowCreateInfoQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM; out_ext->pNext = NULL; - out_ext->customBorderColor = in_ext->customBorderColor; - out_ext->format = in_ext->format; + out_ext->windowExtent = in_ext->windowExtent; + out_ext->windowCompareMode = in_ext->windowCompareMode; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -25629,36 +25618,47 @@ static void convert_VkSamplerCreateInfo_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: { - VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + VkSamplerCubicWeightsCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSamplerCubicWeightsCreateInfoQCOM32 *in_ext = (const VkSamplerCubicWeightsCreateInfoQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM; out_ext->pNext = NULL; - out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData); + out_ext->cubicWeights = in_ext->cubicWeights; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: { - VkSamplerCubicWeightsCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSamplerCubicWeightsCreateInfoQCOM32 *in_ext = (const VkSamplerCubicWeightsCreateInfoQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM; + VkSamplerCustomBorderColorCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSamplerCustomBorderColorCreateInfoEXT32 *in_ext = (const VkSamplerCustomBorderColorCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->cubicWeights = in_ext->cubicWeights; + out_ext->customBorderColor = in_ext->customBorderColor; + out_ext->format = in_ext->format; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: { - VkSamplerBlockMatchWindowCreateInfoQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSamplerBlockMatchWindowCreateInfoQCOM32 *in_ext = (const VkSamplerBlockMatchWindowCreateInfoQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM; + VkSamplerReductionModeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSamplerReductionModeCreateInfo32 *in_ext = (const VkSamplerReductionModeCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO; out_ext->pNext = NULL; - out_ext->windowExtent = in_ext->windowExtent; - out_ext->windowCompareMode = in_ext->windowCompareMode; + out_ext->reductionMode = in_ext->reductionMode; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + { + VkSamplerYcbcrConversionInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSamplerYcbcrConversionInfo32 *in_ext = (const VkSamplerYcbcrConversionInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO; + out_ext->pNext = NULL; + out_ext->conversion = in_ext->conversion; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -25737,25 +25737,25 @@ static void convert_VkSemaphoreCreateInfo_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: + case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: { - VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO; + VkQueryLowLatencySupportNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkQueryLowLatencySupportNV32 *in_ext = (const VkQueryLowLatencySupportNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV; out_ext->pNext = NULL; - out_ext->semaphoreType = in_ext->semaphoreType; - out_ext->initialValue = in_ext->initialValue; + out_ext->pQueriedLowLatencyData = UlongToPtr(in_ext->pQueriedLowLatencyData); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: { - VkQueryLowLatencySupportNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkQueryLowLatencySupportNV32 *in_ext = (const VkQueryLowLatencySupportNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV; + VkSemaphoreTypeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSemaphoreTypeCreateInfo32 *in_ext = (const VkSemaphoreTypeCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO; out_ext->pNext = NULL; - out_ext->pQueriedLowLatencyData = UlongToPtr(in_ext->pQueriedLowLatencyData); + out_ext->semaphoreType = in_ext->semaphoreType; + out_ext->initialValue = in_ext->initialValue; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -25784,7 +25784,18 @@ static void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_con { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: + case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: + { + VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT; + out_ext->pNext = NULL; + out_ext->validationCache = in_ext->validationCache; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: { VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); const VkValidationFeaturesEXT32 *in_ext = (const VkValidationFeaturesEXT32 *)in_header; @@ -25798,17 +25809,6 @@ static void convert_VkShaderModuleCreateInfo_win32_to_host(struct conversion_con out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: - { - VkShaderModuleValidationCacheCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkShaderModuleValidationCacheCreateInfoEXT32 *in_ext = (const VkShaderModuleValidationCacheCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT; - out_ext->pNext = NULL; - out_ext->validationCache = in_ext->validationCache; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -25842,6 +25842,17 @@ static void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion_contex { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: + { + VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO; + out_ext->pNext = NULL; + out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: { VkValidationFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -25856,17 +25867,6 @@ static void convert_VkShaderCreateInfoEXT_win32_to_host(struct conversion_contex out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: - { - VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *in_ext = (const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO; - out_ext->pNext = NULL; - out_ext->requiredSubgroupSize = in_ext->requiredSubgroupSize; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -25931,6 +25931,19 @@ static void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(struct conv out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: + { + VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT; + out_ext->pNext = NULL; + out_ext->flags = in_ext->flags; + out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount; + out_ext->pFixedRateFlags = UlongToPtr(in_ext->pFixedRateFlags); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: { VkImageFormatListCreateInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -25943,26 +25956,24 @@ static void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(struct conv out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: + case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: { - VkSwapchainPresentBarrierCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSwapchainPresentBarrierCreateInfoNV32 *in_ext = (const VkSwapchainPresentBarrierCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV; + VkSwapchainLatencyCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSwapchainLatencyCreateInfoNV32 *in_ext = (const VkSwapchainLatencyCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV; out_ext->pNext = NULL; - out_ext->presentBarrierEnable = in_ext->presentBarrierEnable; + out_ext->latencyModeEnable = in_ext->latencyModeEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: + case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: { - VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT; + VkSwapchainPresentBarrierCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSwapchainPresentBarrierCreateInfoNV32 *in_ext = (const VkSwapchainPresentBarrierCreateInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount; - out_ext->pFixedRateFlags = UlongToPtr(in_ext->pFixedRateFlags); + out_ext->presentBarrierEnable = in_ext->presentBarrierEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -25992,17 +26003,6 @@ static void convert_VkSwapchainCreateInfoKHR_win32_to_unwrapped_host(struct conv out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: - { - VkSwapchainLatencyCreateInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSwapchainLatencyCreateInfoNV32 *in_ext = (const VkSwapchainLatencyCreateInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV; - out_ext->pNext = NULL; - out_ext->latencyModeEnable = in_ext->latencyModeEnable; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -26061,24 +26061,24 @@ static void convert_VkTensorCreateInfoARM_win32_to_host(struct conversion_contex { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: { - VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; + VkExternalMemoryTensorCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkExternalMemoryTensorCreateInfoARM32 *in_ext = (const VkExternalMemoryTensorCreateInfoARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM; out_ext->pNext = NULL; - out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData); + out_ext->handleTypes = in_ext->handleTypes; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: + case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: { - VkExternalMemoryTensorCreateInfoARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkExternalMemoryTensorCreateInfoARM32 *in_ext = (const VkExternalMemoryTensorCreateInfoARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM; + VkOpaqueCaptureDescriptorDataCreateInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *in_ext = (const VkOpaqueCaptureDescriptorDataCreateInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT; out_ext->pNext = NULL; - out_ext->handleTypes = in_ext->handleTypes; + out_ext->opaqueCaptureDescriptorData = UlongToPtr(in_ext->opaqueCaptureDescriptorData); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -26161,18 +26161,6 @@ static void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conversion_ { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: - { - VkVideoEncodeH264SessionCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeH264SessionCreateInfoKHR32 *in_ext = (const VkVideoEncodeH264SessionCreateInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR; - out_ext->pNext = NULL; - out_ext->useMaxLevelIdc = in_ext->useMaxLevelIdc; - out_ext->maxLevelIdc = in_ext->maxLevelIdc; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR: { VkVideoEncodeAV1SessionCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -26185,6 +26173,18 @@ static void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: + { + VkVideoEncodeH264SessionCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeH264SessionCreateInfoKHR32 *in_ext = (const VkVideoEncodeH264SessionCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->useMaxLevelIdc = in_ext->useMaxLevelIdc; + out_ext->maxLevelIdc = in_ext->maxLevelIdc; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR: { VkVideoEncodeSessionIntraRefreshCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -26203,6 +26203,42 @@ static void convert_VkVideoSessionCreateInfoKHR_win32_to_host(struct conversion_ } }

+static void convert_StdVideoAV1SequenceHeader_win32_to_host(const StdVideoAV1SequenceHeader32 *in, StdVideoAV1SequenceHeader *out) +{ + if (!in) return; + + out->flags = in->flags; + out->seq_profile = in->seq_profile; + out->frame_width_bits_minus_1 = in->frame_width_bits_minus_1; + out->frame_height_bits_minus_1 = in->frame_height_bits_minus_1; + out->max_frame_width_minus_1 = in->max_frame_width_minus_1; + out->max_frame_height_minus_1 = in->max_frame_height_minus_1; + out->delta_frame_id_length_minus_2 = in->delta_frame_id_length_minus_2; + out->additional_frame_id_length_minus_1 = in->additional_frame_id_length_minus_1; + out->order_hint_bits_minus_1 = in->order_hint_bits_minus_1; + out->seq_force_integer_mv = in->seq_force_integer_mv; + out->seq_force_screen_content_tools = in->seq_force_screen_content_tools; + memcpy(out->reserved1, in->reserved1, 5 * sizeof(uint8_t)); + out->pColorConfig = UlongToPtr(in->pColorConfig); + out->pTimingInfo = UlongToPtr(in->pTimingInfo); +} + +static const StdVideoAV1SequenceHeader *convert_StdVideoAV1SequenceHeader_array_win32_to_host(struct conversion_context *ctx, const StdVideoAV1SequenceHeader32 *in, uint32_t count) +{ + StdVideoAV1SequenceHeader *out; + unsigned int i; + + if (!in || !count) return NULL; + + out = conversion_context_alloc(ctx, count * sizeof(*out)); + for (i = 0; i < count; i++) + { + convert_StdVideoAV1SequenceHeader_win32_to_host(&in[i], &out[i]); + } + + return out; +} + static void convert_StdVideoH264SequenceParameterSetVui_win32_to_host(const StdVideoH264SequenceParameterSetVui32 *in, StdVideoH264SequenceParameterSetVui *out) { if (!in) return; @@ -26351,42 +26387,6 @@ static const VkVideoDecodeH264SessionParametersAddInfoKHR *convert_VkVideoDecode return out; }

-static void convert_StdVideoAV1SequenceHeader_win32_to_host(const StdVideoAV1SequenceHeader32 *in, StdVideoAV1SequenceHeader *out) -{ - if (!in) return; - - out->flags = in->flags; - out->seq_profile = in->seq_profile; - out->frame_width_bits_minus_1 = in->frame_width_bits_minus_1; - out->frame_height_bits_minus_1 = in->frame_height_bits_minus_1; - out->max_frame_width_minus_1 = in->max_frame_width_minus_1; - out->max_frame_height_minus_1 = in->max_frame_height_minus_1; - out->delta_frame_id_length_minus_2 = in->delta_frame_id_length_minus_2; - out->additional_frame_id_length_minus_1 = in->additional_frame_id_length_minus_1; - out->order_hint_bits_minus_1 = in->order_hint_bits_minus_1; - out->seq_force_integer_mv = in->seq_force_integer_mv; - out->seq_force_screen_content_tools = in->seq_force_screen_content_tools; - memcpy(out->reserved1, in->reserved1, 5 * sizeof(uint8_t)); - out->pColorConfig = UlongToPtr(in->pColorConfig); - out->pTimingInfo = UlongToPtr(in->pTimingInfo); -} - -static const StdVideoAV1SequenceHeader *convert_StdVideoAV1SequenceHeader_array_win32_to_host(struct conversion_context *ctx, const StdVideoAV1SequenceHeader32 *in, uint32_t count) -{ - StdVideoAV1SequenceHeader *out; - unsigned int i; - - if (!in || !count) return NULL; - - out = conversion_context_alloc(ctx, count * sizeof(*out)); - for (i = 0; i < count; i++) - { - convert_StdVideoAV1SequenceHeader_win32_to_host(&in[i], &out[i]); - } - - return out; -} - static void convert_VkVideoEncodeH264SessionParametersAddInfoKHR_win32_to_host(struct conversion_context *ctx, const VkVideoEncodeH264SessionParametersAddInfoKHR32 *in, VkVideoEncodeH264SessionParametersAddInfoKHR *out) { if (!in) return; @@ -26434,6 +26434,17 @@ static void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(struct c { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: + { + VkVideoDecodeAV1SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoDecodeAV1SessionParametersCreateInfoKHR32 *in_ext = (const VkVideoDecodeAV1SessionParametersCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; + out_ext->pNext = NULL; + out_ext->pStdSequenceHeader = convert_StdVideoAV1SequenceHeader_array_win32_to_host(ctx, (const StdVideoAV1SequenceHeader32 *)UlongToPtr(in_ext->pStdSequenceHeader), 1); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: { VkVideoDecodeH264SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -26447,24 +26458,29 @@ static void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(struct c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: { - VkVideoDecodeAV1SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoDecodeAV1SessionParametersCreateInfoKHR32 *in_ext = (const VkVideoDecodeAV1SessionParametersCreateInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; + VkVideoEncodeAV1SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeAV1SessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeAV1SessionParametersCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; out_ext->pNext = NULL; out_ext->pStdSequenceHeader = convert_StdVideoAV1SequenceHeader_array_win32_to_host(ctx, (const StdVideoAV1SequenceHeader32 *)UlongToPtr(in_ext->pStdSequenceHeader), 1); + out_ext->pStdDecoderModelInfo = UlongToPtr(in_ext->pStdDecoderModelInfo); + out_ext->stdOperatingPointCount = in_ext->stdOperatingPointCount; + out_ext->pStdOperatingPoints = UlongToPtr(in_ext->pStdOperatingPoints); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: { - VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR; + VkVideoEncodeH264SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeH264SessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeH264SessionParametersCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; out_ext->pNext = NULL; - out_ext->quantizationMapTexelSize = in_ext->quantizationMapTexelSize; + out_ext->maxStdSPSCount = in_ext->maxStdSPSCount; + out_ext->maxStdPPSCount = in_ext->maxStdPPSCount; + out_ext->pParametersAddInfo = convert_VkVideoEncodeH264SessionParametersAddInfoKHR_array_win32_to_host(ctx, (const VkVideoEncodeH264SessionParametersAddInfoKHR32 *)UlongToPtr(in_ext->pParametersAddInfo), 1); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -26480,29 +26496,13 @@ static void convert_VkVideoSessionParametersCreateInfoKHR_win32_to_host(struct c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR: { - VkVideoEncodeH264SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeH264SessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeH264SessionParametersCreateInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR; + VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR; out_ext->pNext = NULL; - out_ext->maxStdSPSCount = in_ext->maxStdSPSCount; - out_ext->maxStdPPSCount = in_ext->maxStdPPSCount; - out_ext->pParametersAddInfo = convert_VkVideoEncodeH264SessionParametersAddInfoKHR_array_win32_to_host(ctx, (const VkVideoEncodeH264SessionParametersAddInfoKHR32 *)UlongToPtr(in_ext->pParametersAddInfo), 1); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: - { - VkVideoEncodeAV1SessionParametersCreateInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoEncodeAV1SessionParametersCreateInfoKHR32 *in_ext = (const VkVideoEncodeAV1SessionParametersCreateInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR; - out_ext->pNext = NULL; - out_ext->pStdSequenceHeader = convert_StdVideoAV1SequenceHeader_array_win32_to_host(ctx, (const StdVideoAV1SequenceHeader32 *)UlongToPtr(in_ext->pStdSequenceHeader), 1); - out_ext->pStdDecoderModelInfo = UlongToPtr(in_ext->pStdDecoderModelInfo); - out_ext->stdOperatingPointCount = in_ext->stdOperatingPointCount; - out_ext->pStdOperatingPoints = UlongToPtr(in_ext->pStdOperatingPoints); + out_ext->quantizationMapTexelSize = in_ext->quantizationMapTexelSize; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -27706,19 +27706,19 @@ static void convert_VkSubresourceLayout2_win32_to_host(struct conversion_context { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: { - VkSubresourceHostMemcpySize *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE; + VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: { - VkImageCompressionPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT; + VkSubresourceHostMemcpySize *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -27755,15 +27755,6 @@ static void convert_VkSubresourceLayout2_host_to_win32(const VkSubresourceLayout { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: - { - VkSubresourceHostMemcpySize32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE); - const VkSubresourceHostMemcpySize *in_ext = (const VkSubresourceHostMemcpySize *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE; - out_ext->size = in_ext->size; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: { VkImageCompressionPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT); @@ -27774,6 +27765,15 @@ static void convert_VkSubresourceLayout2_host_to_win32(const VkSubresourceLayout out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: + { + VkSubresourceHostMemcpySize32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE); + const VkSubresourceHostMemcpySize *in_ext = (const VkSubresourceHostMemcpySize *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE; + out_ext->size = in_ext->size; + out_header = (void *)out_ext; + break; + } default: break; } @@ -28721,1689 +28721,1569 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: { - VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; + VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; out_ext->pNext = NULL; - out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; + out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; + out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; + out_ext->storagePushConstant16 = in_ext->storagePushConstant16; + out_ext->storageInputOutput16 = in_ext->storageInputOutput16; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: { - VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; + VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute; - out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines; - out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay; + out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4; + out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: { - VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; + VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; out_ext->pNext = NULL; - out_ext->privateData = in_ext->privateData; + out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; + out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; + out_ext->storagePushConstant8 = in_ext->storagePushConstant8; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: { - VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; + VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure; + out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: { - VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; + VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; - out_ext->variablePointers = in_ext->variablePointers; + out_ext->accelerationStructure = in_ext->accelerationStructure; + out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay; + out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild; + out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands; + out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: { - VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; + VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->multiview = in_ext->multiview; - out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; - out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; + out_ext->reportAddressBinding = in_ext->reportAddressBinding; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: { - VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; + VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAntiLagFeaturesAMD32 *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; out_ext->pNext = NULL; - out_ext->presentId = in_ext->presentId; + out_ext->antiLag = in_ext->antiLag; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: { - VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentId2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; + VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->presentId2 = in_ext->presentId2; + out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: { - VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; + VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->presentWait = in_ext->presentWait; + out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: { - VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentWait2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->presentWait2 = in_ext->presentWait2; + out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: { - VkPhysicalDevice16BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevice16BitStorageFeatures32 *in_ext = (const VkPhysicalDevice16BitStorageFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; + VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; - out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; - out_ext->storagePushConstant16 = in_ext->storagePushConstant16; - out_ext->storageInputOutput16 = in_ext->storageInputOutput16; + out_ext->borderColorSwizzle = in_ext->borderColorSwizzle; + out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: { - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; + VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; out_ext->pNext = NULL; - out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; + out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; + out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; + out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: { - VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; + VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; + out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; + out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; + out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: { - VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; + VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->protectedMemory = in_ext->protectedMemory; + out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: { - VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; + VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI; out_ext->pNext = NULL; - out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations; + out_ext->clustercullingShader = in_ext->clustercullingShader; + out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: { - VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; + VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; out_ext->pNext = NULL; - out_ext->multiDraw = in_ext->multiDraw; + out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: { - VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; + VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; - out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; + out_ext->colorWriteEnable = in_ext->colorWriteEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: { - VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; + VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->maintenance4 = in_ext->maintenance4; + out_ext->commandBufferInheritance = in_ext->commandBufferInheritance; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: { - VkPhysicalDeviceMaintenance5Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance5Features32 *in_ext = (const VkPhysicalDeviceMaintenance5Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; + VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->maintenance5 = in_ext->maintenance5; + out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads; + out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: { - VkPhysicalDeviceMaintenance6Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance6Features32 *in_ext = (const VkPhysicalDeviceMaintenance6Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; + VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->maintenance6 = in_ext->maintenance6; + out_ext->conditionalRendering = in_ext->conditionalRendering; + out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: { - VkPhysicalDeviceMaintenance8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance8FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; + VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; out_ext->pNext = NULL; - out_ext->maintenance8 = in_ext->maintenance8; + out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope; + out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions; + out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions; + out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions; + out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations; + out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing; + out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: { - VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMaintenance9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; + VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->maintenance9 = in_ext->maintenance9; + out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; + out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: { - VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; + VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; + out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; + out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: { - VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; + VkPhysicalDeviceCooperativeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shaderFloat16 = in_ext->shaderFloat16; - out_ext->shaderInt8 = in_ext->shaderInt8; + out_ext->cooperativeVector = in_ext->cooperativeVector; + out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: { - VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; + VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; out_ext->pNext = NULL; - out_ext->hostQueryReset = in_ext->hostQueryReset; + out_ext->indirectCopy = in_ext->indirectCopy; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: { - VkPhysicalDeviceGlobalPriorityQueryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; + VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; + out_ext->cornerSampledImage = in_ext->cornerSampledImage; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: { - VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; + VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; - out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; - out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; - out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; - out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; - out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; - out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; - out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; - out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; - out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; - out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; - out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; - out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; - out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; - out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; - out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; - out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; - out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; - out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; - out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; + out_ext->coverageReductionMode = in_ext->coverageReductionMode; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: { - VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; + VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCubicClampFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->timelineSemaphore = in_ext->timelineSemaphore; + out_ext->cubicRangeClamp = in_ext->cubicRangeClamp; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: { - VkPhysicalDevice8BitStorageFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevice8BitStorageFeatures32 *in_ext = (const VkPhysicalDevice8BitStorageFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; + VkPhysicalDeviceCubicWeightsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; - out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; - out_ext->storagePushConstant8 = in_ext->storagePushConstant8; + out_ext->selectableCubicWeights = in_ext->selectableCubicWeights; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: { - VkPhysicalDeviceConditionalRenderingFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; + VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->conditionalRendering = in_ext->conditionalRendering; - out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering; + out_ext->customBorderColors = in_ext->customBorderColors; + out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: { - VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; + VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDataGraphFeaturesARM32 *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; - out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; - out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; + out_ext->dataGraph = in_ext->dataGraph; + out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind; + out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants; + out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer; + out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: { - VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; + VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; - out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; + out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; + VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics; - out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd; - out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics; - out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd; - out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics; - out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd; - out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics; - out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd; - out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics; - out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd; - out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics; - out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd; + out_ext->depthBiasControl = in_ext->depthBiasControl; + out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation; + out_ext->floatRepresentation = in_ext->floatRepresentation; + out_ext->depthBiasExact = in_ext->depthBiasExact; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; + VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics; - out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd; - out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax; - out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax; - out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax; - out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics; - out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd; - out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax; - out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax; - out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax; - out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax; - out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax; + out_ext->depthClampControl = in_ext->depthClampControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: { - VkPhysicalDeviceVertexAttributeDivisorFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; + VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; - out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; + out_ext->depthClampZeroOne = in_ext->depthClampZeroOne; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceASTCDecodeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; + VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent; + out_ext->depthClipControl = in_ext->depthClipControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: { - VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; + VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->transformFeedback = in_ext->transformFeedback; - out_ext->geometryStreams = in_ext->geometryStreams; + out_ext->depthClipEnable = in_ext->depthClipEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: { - VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; + VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->representativeFragmentTest = in_ext->representativeFragmentTest; + out_ext->descriptorBuffer = in_ext->descriptorBuffer; + out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay; + out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored; + out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: { - VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; + VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->exclusiveScissor = in_ext->exclusiveScissor; + out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: { - VkPhysicalDeviceCornerSampledImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; + VkPhysicalDeviceDescriptorIndexingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorIndexingFeatures32 *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; out_ext->pNext = NULL; - out_ext->cornerSampledImage = in_ext->cornerSampledImage; + out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; + out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; + out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; + out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; + out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; + out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; + out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; + out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; + out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; + out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; + out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; + out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; + out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; + out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; + out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; + out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; + out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; + out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; + out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; + out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: { - VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; + VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; out_ext->pNext = NULL; - out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads; - out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear; + out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: { - VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; + VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; out_ext->pNext = NULL; - out_ext->imageFootprint = in_ext->imageFootprint; + out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: { - VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; + VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing; + out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute; + out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines; + out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: { - VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->indirectCopy = in_ext->indirectCopy; + out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; + out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: { - VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; out_ext->pNext = NULL; - out_ext->memoryDecompression = in_ext->memoryDecompression; + out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: { - VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; + VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; out_ext->pNext = NULL; - out_ext->shadingRateImage = in_ext->shadingRateImage; - out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder; + out_ext->diagnosticsConfig = in_ext->diagnosticsConfig; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: { - VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; + VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; out_ext->pNext = NULL; - out_ext->invocationMask = in_ext->invocationMask; + out_ext->dynamicRendering = in_ext->dynamicRendering; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: { - VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; + VkPhysicalDeviceDynamicRenderingLocalReadFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; out_ext->pNext = NULL; - out_ext->taskShader = in_ext->taskShader; - out_ext->meshShader = in_ext->meshShader; + out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: { - VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; + VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->taskShader = in_ext->taskShader; - out_ext->meshShader = in_ext->meshShader; - out_ext->multiviewMeshShader = in_ext->multiviewMeshShader; - out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader; - out_ext->meshShaderQueries = in_ext->meshShaderQueries; + out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: { - VkPhysicalDeviceAccelerationStructureFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; + VkPhysicalDeviceExclusiveScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->accelerationStructure = in_ext->accelerationStructure; - out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay; - out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild; - out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands; - out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind; + out_ext->exclusiveScissor = in_ext->exclusiveScissor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: { - VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->rayTracingPipeline = in_ext->rayTracingPipeline; - out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay; - out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed; - out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect; - out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling; + out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2; + out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp; + out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: { - VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; + VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->rayQuery = in_ext->rayQuery; + out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin; + out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable; + out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode; + out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples; + out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask; + out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable; + out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable; + out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable; + out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable; + out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation; + out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask; + out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream; + out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode; + out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize; + out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable; + out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable; + out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced; + out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode; + out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode; + out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable; + out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne; + out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable; + out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle; + out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable; + out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation; + out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode; + out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable; + out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable; + out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode; + out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable; + out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: { - VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1; - out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2; + out_ext->extendedDynamicState = in_ext->extendedDynamicState; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: { - VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; + VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->fragmentDensityMap = in_ext->fragmentDensityMap; - out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic; - out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages; + out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: { - VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; + VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred; + out_ext->deviceFault = in_ext->deviceFault; + out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: { - VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT; + VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFormatPackFeaturesARM32 *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset; + out_ext->formatPack = in_ext->formatPack; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: { - VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; + VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; + out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: { - VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; + VkPhysicalDeviceFragmentDensityMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; + out_ext->fragmentDensityMap = in_ext->fragmentDensityMap; + out_ext->fragmentDensityMapDynamic = in_ext->fragmentDensityMapDynamic; + out_ext->fragmentDensityMapNonSubsampledImages = in_ext->fragmentDensityMapNonSubsampledImages; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: { - VkPhysicalDeviceDepthClipEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; + VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; out_ext->pNext = NULL; - out_ext->depthClipEnable = in_ext->depthClipEnable; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: { - VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; + VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->memoryPriority = in_ext->memoryPriority; + out_ext->fragmentDensityMapOffset = in_ext->fragmentDensityMapOffset; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: { - VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; + VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory; + out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: { - VkPhysicalDeviceBufferDeviceAddressFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceBufferDeviceAddressFeatures32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; + VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; - out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; - out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; + out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock; + out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock; + out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: { - VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; + VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; out_ext->pNext = NULL; - out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; - out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; - out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; + out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums; + out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates; + out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: { - VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; + VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; + out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate; + out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate; + out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: { - VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; + VkPhysicalDeviceFrameBoundaryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; + out_ext->frameBoundary = in_ext->frameBoundary; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: { - VkPhysicalDeviceCooperativeMatrixFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; + VkPhysicalDeviceGlobalPriorityQueryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; out_ext->pNext = NULL; - out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; - out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; + out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: { - VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; + VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays; + out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: { - VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; + VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; out_ext->pNext = NULL; - out_ext->presentBarrier = in_ext->presentBarrier; + out_ext->hdrVivid = in_ext->hdrVivid; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: { - VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; + VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHostImageCopyFeatures32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; out_ext->pNext = NULL; - out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools; - out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools; + out_ext->hostImageCopy = in_ext->hostImageCopy; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: { - VkPhysicalDeviceCoverageReductionModeFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; + VkPhysicalDeviceHostQueryResetFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHostQueryResetFeatures32 *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; out_ext->pNext = NULL; - out_ext->coverageReductionMode = in_ext->coverageReductionMode; + out_ext->hostQueryReset = in_ext->hostQueryReset; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: { - VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2; + out_ext->image2DViewOf3D = in_ext->image2DViewOf3D; + out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: { - VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; + VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; out_ext->pNext = NULL; - out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock; - out_ext->shaderDeviceClock = in_ext->shaderDeviceClock; + out_ext->imageAlignmentControl = in_ext->imageAlignmentControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceIndexTypeUint8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceIndexTypeUint8Features32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; + VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->indexTypeUint8 = in_ext->indexTypeUint8; + out_ext->imageCompressionControl = in_ext->imageCompressionControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: { - VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; + VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins; + out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: { - VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; + VkPhysicalDeviceImageProcessing2FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock; - out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock; - out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock; + out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: { - VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; + VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; + out_ext->textureSampleWeighted = in_ext->textureSampleWeighted; + out_ext->textureBoxFilter = in_ext->textureBoxFilter; + out_ext->textureBlockMatch = in_ext->textureBlockMatch; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: { - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; + VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; out_ext->pNext = NULL; - out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart; - out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart; + out_ext->robustImageAccess = in_ext->robustImageAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: { - VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; + VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo; + out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: { - VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; + VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; + out_ext->minLod = in_ext->minLod; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: { - VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; + VkPhysicalDeviceImagelessFramebufferFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImagelessFramebufferFeatures32 *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; out_ext->pNext = NULL; - out_ext->texelBufferAlignment = in_ext->texelBufferAlignment; + out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: { - VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; + VkPhysicalDeviceIndexTypeUint8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceIndexTypeUint8Features32 *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; out_ext->pNext = NULL; - out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; - out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; + out_ext->indexTypeUint8 = in_ext->indexTypeUint8; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: { - VkPhysicalDeviceLineRasterizationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLineRasterizationFeatures32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; + VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->rectangularLines = in_ext->rectangularLines; - out_ext->bresenhamLines = in_ext->bresenhamLines; - out_ext->smoothLines = in_ext->smoothLines; - out_ext->stippledRectangularLines = in_ext->stippledRectangularLines; - out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines; - out_ext->stippledSmoothLines = in_ext->stippledSmoothLines; + out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: { - VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; + VkPhysicalDeviceInlineUniformBlockFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceInlineUniformBlockFeatures32 *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; out_ext->pNext = NULL; - out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; + out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; + out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: { - VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; + VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; out_ext->pNext = NULL; - out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; - out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; - out_ext->storagePushConstant16 = in_ext->storagePushConstant16; - out_ext->storageInputOutput16 = in_ext->storageInputOutput16; - out_ext->multiview = in_ext->multiview; - out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; - out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; - out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; - out_ext->variablePointers = in_ext->variablePointers; - out_ext->protectedMemory = in_ext->protectedMemory; - out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; - out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; + out_ext->invocationMask = in_ext->invocationMask; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: { - VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; + VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge; - out_ext->drawIndirectCount = in_ext->drawIndirectCount; - out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; - out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; - out_ext->storagePushConstant8 = in_ext->storagePushConstant8; - out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; - out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; - out_ext->shaderFloat16 = in_ext->shaderFloat16; - out_ext->shaderInt8 = in_ext->shaderInt8; - out_ext->descriptorIndexing = in_ext->descriptorIndexing; - out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; - out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; - out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; - out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; - out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; - out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; - out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; - out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; - out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; - out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; - out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; - out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; - out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; - out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; - out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; - out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; - out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; - out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; - out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; - out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; - out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax; - out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; - out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; - out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; - out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; - out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; - out_ext->hostQueryReset = in_ext->hostQueryReset; - out_ext->timelineSemaphore = in_ext->timelineSemaphore; - out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; - out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; - out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; - out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; - out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; - out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; - out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex; - out_ext->shaderOutputLayer = in_ext->shaderOutputLayer; - out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId; + out_ext->legacyDithering = in_ext->legacyDithering; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: { - VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; + VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->robustImageAccess = in_ext->robustImageAccess; - out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; - out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; - out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; - out_ext->privateData = in_ext->privateData; - out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; - out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; - out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; - out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; - out_ext->synchronization2 = in_ext->synchronization2; - out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; - out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; - out_ext->dynamicRendering = in_ext->dynamicRendering; - out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; - out_ext->maintenance4 = in_ext->maintenance4; + out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: { - VkPhysicalDeviceVulkan14Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVulkan14Features32 *in_ext = (const VkPhysicalDeviceVulkan14Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; + VkPhysicalDeviceLineRasterizationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLineRasterizationFeatures32 *in_ext = (const VkPhysicalDeviceLineRasterizationFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES; out_ext->pNext = NULL; - out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; - out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; - out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; - out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; - out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; out_ext->rectangularLines = in_ext->rectangularLines; out_ext->bresenhamLines = in_ext->bresenhamLines; out_ext->smoothLines = in_ext->smoothLines; out_ext->stippledRectangularLines = in_ext->stippledRectangularLines; out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines; out_ext->stippledSmoothLines = in_ext->stippledSmoothLines; - out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; - out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; - out_ext->indexTypeUint8 = in_ext->indexTypeUint8; - out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; - out_ext->maintenance5 = in_ext->maintenance5; - out_ext->maintenance6 = in_ext->maintenance6; - out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; - out_ext->pipelineRobustness = in_ext->pipelineRobustness; - out_ext->hostImageCopy = in_ext->hostImageCopy; - out_ext->pushDescriptor = in_ext->pushDescriptor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: { - VkPhysicalDeviceCoherentMemoryFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; + VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; out_ext->pNext = NULL; - out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory; + out_ext->linearColorAttachment = in_ext->linearColorAttachment; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: { - VkPhysicalDeviceCustomBorderColorFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; + VkPhysicalDeviceMaintenance4Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance4Features32 *in_ext = (const VkPhysicalDeviceMaintenance4Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; out_ext->pNext = NULL; - out_ext->customBorderColors = in_ext->customBorderColors; - out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat; + out_ext->maintenance4 = in_ext->maintenance4; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: { - VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; + VkPhysicalDeviceMaintenance5Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance5Features32 *in_ext = (const VkPhysicalDeviceMaintenance5Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; out_ext->pNext = NULL; - out_ext->borderColorSwizzle = in_ext->borderColorSwizzle; - out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage; + out_ext->maintenance5 = in_ext->maintenance5; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: { - VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; + VkPhysicalDeviceMaintenance6Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance6Features32 *in_ext = (const VkPhysicalDeviceMaintenance6Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; out_ext->pNext = NULL; - out_ext->extendedDynamicState = in_ext->extendedDynamicState; + out_ext->maintenance6 = in_ext->maintenance6; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: { - VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; + VkPhysicalDeviceMaintenance8FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance8FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2; - out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp; - out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints; + out_ext->maintenance8 = in_ext->maintenance8; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: { - VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; + VkPhysicalDeviceMaintenance9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMaintenance9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin; - out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable; - out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode; - out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples; - out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask; - out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable; - out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable; - out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable; - out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable; - out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation; - out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask; - out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream; - out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode; - out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize; - out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable; - out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable; - out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced; - out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode; - out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode; - out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable; - out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne; - out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable; - out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle; - out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable; - out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation; - out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode; - out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable; - out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable; - out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode; - out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable; - out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable; + out_ext->maintenance9 = in_ext->maintenance9; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: { - VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; + VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure; + out_ext->memoryMapPlaced = in_ext->memoryMapPlaced; + out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced; + out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: { - VkPhysicalDeviceDiagnosticsConfigFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; + VkPhysicalDeviceMemoryDecompressionFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; out_ext->pNext = NULL; - out_ext->diagnosticsConfig = in_ext->diagnosticsConfig; + out_ext->memoryDecompression = in_ext->memoryDecompression; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: { - VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; + VkPhysicalDeviceMemoryPriorityFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; + out_ext->memoryPriority = in_ext->memoryPriority; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: { - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; + VkPhysicalDeviceMeshShaderFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMeshShaderFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow; + out_ext->taskShader = in_ext->taskShader; + out_ext->meshShader = in_ext->meshShader; + out_ext->multiviewMeshShader = in_ext->multiviewMeshShader; + out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader; + out_ext->meshShaderQueries = in_ext->meshShaderQueries; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: { - VkPhysicalDeviceRobustness2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRobustness2FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; + VkPhysicalDeviceMeshShaderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMeshShaderFeaturesNV32 *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; out_ext->pNext = NULL; - out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2; - out_ext->robustImageAccess2 = in_ext->robustImageAccess2; - out_ext->nullDescriptor = in_ext->nullDescriptor; + out_ext->taskShader = in_ext->taskShader; + out_ext->meshShader = in_ext->meshShader; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: { - VkPhysicalDeviceImageRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageRobustnessFeatures32 *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; + VkPhysicalDeviceMultiDrawFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultiDrawFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->robustImageAccess = in_ext->robustImageAccess; + out_ext->multiDraw = in_ext->multiDraw; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: { - VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; + VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout; - out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout; - out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess; - out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess; + out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { - VkPhysicalDevice4444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevice4444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; + VkPhysicalDeviceMultiviewFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultiviewFeatures32 *in_ext = (const VkPhysicalDeviceMultiviewFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; out_ext->pNext = NULL; - out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4; - out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4; + out_ext->multiview = in_ext->multiview; + out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; + out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: { - VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; + VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->subpassShading = in_ext->subpassShading; + out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: { - VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI; + VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->clustercullingShader = in_ext->clustercullingShader; - out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader; + out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: { - VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; + VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics; - out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics; + out_ext->mutableDescriptorType = in_ext->mutableDescriptorType; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: { - VkPhysicalDeviceFragmentShadingRateFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; + VkPhysicalDeviceNestedCommandBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate; - out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate; - out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate; + out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer; + out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering; + out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: { - VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; + VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; + out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: { - VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; + VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums; - out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates; - out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates; + out_ext->micromap = in_ext->micromap; + out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay; + out_ext->micromapHostCommands = in_ext->micromapHostCommands; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: { - VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; + VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; out_ext->pNext = NULL; - out_ext->image2DViewOf3D = in_ext->image2DViewOf3D; - out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D; + out_ext->opticalFlow = in_ext->opticalFlow; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: { - VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; + VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D; + out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: { - VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; + VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState; + out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: { - VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; + VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; out_ext->pNext = NULL; - out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes; + out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet; + out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: { - VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; + VkPhysicalDevicePerformanceQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->mutableDescriptorType = in_ext->mutableDescriptorType; + out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools; + out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: { - VkPhysicalDeviceDepthClipControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; + VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->depthClipControl = in_ext->depthClipControl; + out_ext->pipelineBinaries = in_ext->pipelineBinaries; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: { - VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; + VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; out_ext->pNext = NULL; - out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory; + out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: { - VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; + VkPhysicalDevicePipelineCreationCacheControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; out_ext->pNext = NULL; - out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; - out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout; + out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: { - VkPhysicalDeviceDepthClampControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; - out_ext->pNext = NULL; - out_ext->depthClampControl = in_ext->depthClampControl; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: - { - VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; + VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState; + out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: { - VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; + VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction; + out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: { - VkPhysicalDeviceColorWriteEnableFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; + VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->colorWriteEnable = in_ext->colorWriteEnable; + out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: { - VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; + VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->synchronization2 = in_ext->synchronization2; + out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: { - VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; + VkPhysicalDevicePipelineProtectedAccessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineProtectedAccessFeatures32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; out_ext->pNext = NULL; - out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts; - out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo; + out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: { - VkPhysicalDeviceHostImageCopyFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceHostImageCopyFeatures32 *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; + VkPhysicalDevicePipelineRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePipelineRobustnessFeatures32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; out_ext->pNext = NULL; - out_ext->hostImageCopy = in_ext->hostImageCopy; + out_ext->pipelineRobustness = in_ext->pipelineRobustness; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: { - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; + VkPhysicalDevicePresentBarrierFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentBarrierFeaturesNV32 *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; out_ext->pNext = NULL; - out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery; - out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard; - out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams; + out_ext->presentBarrier = in_ext->presentBarrier; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: { - VkPhysicalDeviceLegacyDitheringFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; + VkPhysicalDevicePresentId2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentId2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->legacyDithering = in_ext->legacyDithering; + out_ext->presentId2 = in_ext->presentId2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: { - VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; + VkPhysicalDevicePresentIdFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentIdFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled; + out_ext->presentId = in_ext->presentId; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: { - VkPhysicalDevicePipelineProtectedAccessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineProtectedAccessFeatures32 *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; + out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: { - VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; + VkPhysicalDevicePresentWait2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentWait2FeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->videoMaintenance1 = in_ext->videoMaintenance1; + out_ext->presentWait2 = in_ext->presentWait2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: { - VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; + VkPhysicalDevicePresentWaitFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePresentWaitFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9; + out_ext->presentWait = in_ext->presentWait; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: { - VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap; + out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart; + out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: { - VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1; + out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery; + out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard; + out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: { - VkPhysicalDeviceInheritedViewportScissorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; + VkPhysicalDevicePrivateDataFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDevicePrivateDataFeatures32 *in_ext = (const VkPhysicalDevicePrivateDataFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; out_ext->pNext = NULL; - out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D; + out_ext->privateData = in_ext->privateData; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: { - VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; + VkPhysicalDeviceProtectedMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceProtectedMemoryFeatures32 *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; out_ext->pNext = NULL; - out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats; + out_ext->protectedMemory = in_ext->protectedMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -30420,72 +30300,59 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: - { - VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; - out_ext->pNext = NULL; - out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: { - VkPhysicalDeviceDescriptorBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; + VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->descriptorBuffer = in_ext->descriptorBuffer; - out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay; - out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored; - out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors; + out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: { - VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; + VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; + out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess; + out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess; + out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: { - VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; + VkPhysicalDeviceRawAccessChainsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; out_ext->pNext = NULL; - out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric; + out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: { - VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; + VkPhysicalDeviceRayQueryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayQueryFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur; - out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect; + out_ext->rayQuery = in_ext->rayQuery; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: { - VkPhysicalDeviceRayTracingValidationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; + VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; out_ext->pNext = NULL; - out_ext->rayTracingValidation = in_ext->rayTracingValidation; + out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -30502,909 +30369,1042 @@ static void convert_VkPhysicalDeviceFeatures2_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; + VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler; + out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1; + out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: { - VkPhysicalDeviceDynamicRenderingFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDynamicRenderingFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; + VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->dynamicRendering = in_ext->dynamicRendering; + out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur; + out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: { - VkPhysicalDeviceImageViewMinLodFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; + VkPhysicalDeviceRayTracingPipelineFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->minLod = in_ext->minLod; + out_ext->rayTracingPipeline = in_ext->rayTracingPipeline; + out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay; + out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect; + out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: { - VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; + VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess; - out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess; - out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess; + out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: { - VkPhysicalDeviceLinearColorAttachmentFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; + VkPhysicalDeviceRayTracingValidationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingValidationFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV; out_ext->pNext = NULL; - out_ext->linearColorAttachment = in_ext->linearColorAttachment; + out_ext->rayTracingValidation = in_ext->rayTracingValidation; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: { - VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; out_ext->pNext = NULL; - out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary; + out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: { - VkPhysicalDevicePipelineBinaryFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; + VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->pipelineBinaries = in_ext->pipelineBinaries; + out_ext->renderPassStriped = in_ext->renderPassStriped; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: { - VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; + VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; out_ext->pNext = NULL; - out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping; + out_ext->representativeFragmentTest = in_ext->representativeFragmentTest; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: { - VkPhysicalDeviceNestedCommandBufferFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; + VkPhysicalDeviceRobustness2FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceRobustness2FeaturesKHR32 *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer; - out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering; - out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse; + out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2; + out_ext->robustImageAccess2 = in_ext->robustImageAccess2; + out_ext->nullDescriptor = in_ext->nullDescriptor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: { - VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; + VkPhysicalDeviceSamplerYcbcrConversionFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; out_ext->pNext = NULL; - out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier; + out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: { - VkPhysicalDeviceImageCompressionControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; + VkPhysicalDeviceScalarBlockLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceScalarBlockLayoutFeatures32 *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; out_ext->pNext = NULL; - out_ext->imageCompressionControl = in_ext->imageCompressionControl; + out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: { - VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; + VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain; + out_ext->schedulingControls = in_ext->schedulingControls; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: { - VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; + VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; out_ext->pNext = NULL; - out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback; + out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: { - VkPhysicalDeviceOpacityMicromapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; + VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; out_ext->pNext = NULL; - out_ext->micromap = in_ext->micromap; - out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay; - out_ext->micromapHostCommands = in_ext->micromapHostCommands; + out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: { - VkPhysicalDevicePipelinePropertiesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; + VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier; + out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics; + out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd; + out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax; + out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax; + out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax; + out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics; + out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd; + out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax; + out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax; + out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax; + out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax; + out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: { - VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests; + out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics; + out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd; + out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics; + out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd; + out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics; + out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd; + out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics; + out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd; + out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics; + out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd; + out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics; + out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: { - VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; + VkPhysicalDeviceShaderAtomicInt64Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderAtomicInt64Features32 *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; out_ext->pNext = NULL; - out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap; + out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; + out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: { - VkPhysicalDevicePipelineRobustnessFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineRobustnessFeatures32 *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; + VkPhysicalDeviceShaderBfloat16FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->pipelineRobustness = in_ext->pipelineRobustness; + out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type; + out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct; + out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: { - VkPhysicalDeviceImageProcessingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; + VkPhysicalDeviceShaderClockFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderClockFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->textureSampleWeighted = in_ext->textureSampleWeighted; - out_ext->textureBoxFilter = in_ext->textureBoxFilter; - out_ext->textureBlockMatch = in_ext->textureBlockMatch; + out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock; + out_ext->shaderDeviceClock = in_ext->shaderDeviceClock; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: { - VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; + VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->tileProperties = in_ext->tileProperties; + out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: { - VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; + VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; out_ext->pNext = NULL; - out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout; + out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: { - VkPhysicalDeviceAddressBindingReportFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; + VkPhysicalDeviceShaderDrawParametersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderDrawParametersFeatures32 *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; out_ext->pNext = NULL; - out_ext->reportAddressBinding = in_ext->reportAddressBinding; + out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: { - VkPhysicalDeviceOpticalFlowFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceOpticalFlowFeaturesNV32 *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; + VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *in_ext = (const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD; out_ext->pNext = NULL; - out_ext->opticalFlow = in_ext->opticalFlow; + out_ext->shaderEarlyAndLateFragmentTests = in_ext->shaderEarlyAndLateFragmentTests; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: { - VkPhysicalDeviceFaultFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFaultFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; + VkPhysicalDeviceShaderExpectAssumeFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderExpectAssumeFeatures32 *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; out_ext->pNext = NULL; - out_ext->deviceFault = in_ext->deviceFault; - out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary; + out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: { - VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; + VkPhysicalDeviceShaderFloat16Int8Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloat16Int8Features32 *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; out_ext->pNext = NULL; - out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles; + out_ext->shaderFloat16 = in_ext->shaderFloat16; + out_ext->shaderInt8 = in_ext->shaderInt8; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: { - VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; + VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins; + out_ext->shaderFloat8 = in_ext->shaderFloat8; + out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: { - VkPhysicalDeviceFrameBoundaryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; + VkPhysicalDeviceShaderFloatControls2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderFloatControls2Features32 *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; out_ext->pNext = NULL; - out_ext->frameBoundary = in_ext->frameBoundary; + out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: { - VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; + VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments; + out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics; + out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: { - VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; + VkPhysicalDeviceShaderImageFootprintFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; out_ext->pNext = NULL; - out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1; + out_ext->imageFootprint = in_ext->imageFootprint; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: { - VkPhysicalDeviceDepthBiasControlFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; + VkPhysicalDeviceShaderIntegerDotProductFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; out_ext->pNext = NULL; - out_ext->depthBiasControl = in_ext->depthBiasControl; - out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation; - out_ext->floatRepresentation = in_ext->floatRepresentation; - out_ext->depthBiasExact = in_ext->depthBiasExact; + out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: { - VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; + VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; out_ext->pNext = NULL; - out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder; + out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: { - VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace; + out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: { - VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; + VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports; + out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: { - VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; + VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch; + out_ext->shaderObject = in_ext->shaderObject; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: { - VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM; + VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas; + out_ext->shaderQuadControl = in_ext->shaderQuadControl; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: { - VkPhysicalDeviceShaderObjectFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderObjectFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; + VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->shaderObject = in_ext->shaderObject; + out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: { - VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT; + VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess; - out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess; - out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess; + out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: { - VkPhysicalDeviceCooperativeMatrixFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; + VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; out_ext->pNext = NULL; - out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; - out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; + out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: { - VkPhysicalDeviceAntiLagFeaturesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceAntiLagFeaturesAMD32 *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; out_ext->pNext = NULL; - out_ext->antiLag = in_ext->antiLag; + out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: { - VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; + VkPhysicalDeviceShaderSubgroupRotateFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; out_ext->pNext = NULL; - out_ext->tileMemoryHeap = in_ext->tileMemoryHeap; + out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; + out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: { - VkPhysicalDeviceCubicClampFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCubicClampFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->cubicRangeClamp = in_ext->cubicRangeClamp; + out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: { - VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; + VkPhysicalDeviceShaderTerminateInvocationFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; out_ext->pNext = NULL; - out_ext->ycbcrDegamma = in_ext->ycbcrDegamma; + out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: { - VkPhysicalDeviceCubicWeightsFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; + VkPhysicalDeviceShaderTileImageFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderTileImageFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->selectableCubicWeights = in_ext->selectableCubicWeights; + out_ext->shaderTileImageColorReadAccess = in_ext->shaderTileImageColorReadAccess; + out_ext->shaderTileImageDepthReadAccess = in_ext->shaderTileImageDepthReadAccess; + out_ext->shaderTileImageStencilReadAccess = in_ext->shaderTileImageStencilReadAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: { - VkPhysicalDeviceImageProcessing2FeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; + VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2; + out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: { - VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; + VkPhysicalDeviceShadingRateImageFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceShadingRateImageFeaturesNV32 *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; out_ext->pNext = NULL; - out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation; + out_ext->shadingRateImage = in_ext->shadingRateImage; + out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: { - VkPhysicalDevicePerStageDescriptorSetFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; + VkPhysicalDeviceSubgroupSizeControlFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSubgroupSizeControlFeatures32 *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; out_ext->pNext = NULL; - out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet; - out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout; + out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; + out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: { - VkPhysicalDeviceSchedulingControlsFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; + VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->schedulingControls = in_ext->schedulingControls; + out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: { - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; + VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; out_ext->pNext = NULL; - out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization; + out_ext->subpassShading = in_ext->subpassShading; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceRenderPassStripedFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; + VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->renderPassStriped = in_ext->renderPassStriped; + out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: { - VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; + VkPhysicalDeviceSynchronization2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceSynchronization2Features32 *in_ext = (const VkPhysicalDeviceSynchronization2Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; out_ext->pNext = NULL; - out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap; + out_ext->synchronization2 = in_ext->synchronization2; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: { - VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; + VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceTensorFeaturesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; out_ext->pNext = NULL; - out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence; + out_ext->tensorNonPacked = in_ext->tensorNonPacked; + out_ext->shaderTensorAccess = in_ext->shaderTensorAccess; + out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing; + out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing; + out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind; + out_ext->tensors = in_ext->tensors; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: { - VkPhysicalDeviceShaderSubgroupRotateFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; - out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; + out_ext->texelBufferAlignment = in_ext->texelBufferAlignment; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: { - VkPhysicalDeviceShaderExpectAssumeFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderExpectAssumeFeatures32 *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; + VkPhysicalDeviceTextureCompressionASTCHDRFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; out_ext->pNext = NULL; - out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; + out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: { - VkPhysicalDeviceShaderFloatControls2Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderFloatControls2Features32 *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; + VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; + out_ext->tileMemoryHeap = in_ext->tileMemoryHeap; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: { - VkPhysicalDeviceDynamicRenderingLocalReadFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; + VkPhysicalDeviceTilePropertiesFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; + out_ext->tileProperties = in_ext->tileProperties; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: { - VkPhysicalDeviceShaderQuadControlFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; + VkPhysicalDeviceTileShadingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTileShadingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->shaderQuadControl = in_ext->shaderQuadControl; + out_ext->tileShading = in_ext->tileShading; + out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage; + out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments; + out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments; + out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments; + out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments; + out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments; + out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw; + out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch; + out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile; + out_ext->tileShadingApron = in_ext->tileShadingApron; + out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron; + out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps; + out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: { - VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; + VkPhysicalDeviceTimelineSemaphoreFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTimelineSemaphoreFeatures32 *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; out_ext->pNext = NULL; - out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics; + out_ext->timelineSemaphore = in_ext->timelineSemaphore; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: { - VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; + VkPhysicalDeviceTransformFeedbackFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->memoryMapPlaced = in_ext->memoryMapPlaced; - out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced; - out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve; + out_ext->transformFeedback = in_ext->transformFeedback; + out_ext->geometryStreams = in_ext->geometryStreams; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: { - VkPhysicalDeviceShaderBfloat16FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; + VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type; - out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct; - out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix; + out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts; + out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: { - VkPhysicalDeviceRawAccessChainsFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; + VkPhysicalDeviceUniformBufferStandardLayoutFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; out_ext->pNext = NULL; - out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains; + out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: { - VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; + VkPhysicalDeviceVariablePointersFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVariablePointersFeatures32 *in_ext = (const VkPhysicalDeviceVariablePointersFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; out_ext->pNext = NULL; - out_ext->commandBufferInheritance = in_ext->commandBufferInheritance; + out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; + out_ext->variablePointers = in_ext->variablePointers; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: { - VkPhysicalDeviceImageAlignmentControlFeaturesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; + VkPhysicalDeviceVertexAttributeDivisorFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; out_ext->pNext = NULL; - out_ext->imageAlignmentControl = in_ext->imageAlignmentControl; + out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; + out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: { - VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; + VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites; + out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: { - VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; + VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; + out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: { - VkPhysicalDeviceCooperativeMatrix2FeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; + VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope; - out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions; - out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions; - out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions; - out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations; - out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing; - out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads; + out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: { - VkPhysicalDeviceHdrVividFeaturesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; + VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->hdrVivid = in_ext->hdrVivid; + out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: { - VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; + VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness; + out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: { - VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; + VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->depthClampZeroOne = in_ext->depthClampZeroOne; + out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceCooperativeVectorFeaturesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; + VkPhysicalDeviceVideoMaintenance1FeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->cooperativeVector = in_ext->cooperativeVector; - out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining; + out_ext->videoMaintenance1 = in_ext->videoMaintenance1; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceTileShadingFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTileShadingFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; + VkPhysicalDeviceVulkan11Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkan11Features32 *in_ext = (const VkPhysicalDeviceVulkan11Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; out_ext->pNext = NULL; - out_ext->tileShading = in_ext->tileShading; - out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage; - out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments; - out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments; - out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments; - out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments; - out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments; - out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw; - out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch; - out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile; - out_ext->tileShadingApron = in_ext->tileShadingApron; - out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron; - out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps; - out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing; + out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; + out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; + out_ext->storagePushConstant16 = in_ext->storagePushConstant16; + out_ext->storageInputOutput16 = in_ext->storageInputOutput16; + out_ext->multiview = in_ext->multiview; + out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; + out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; + out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; + out_ext->variablePointers = in_ext->variablePointers; + out_ext->protectedMemory = in_ext->protectedMemory; + out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; + out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; + VkPhysicalDeviceVulkan12Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkan12Features32 *in_ext = (const VkPhysicalDeviceVulkan12Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; out_ext->pNext = NULL; + out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge; + out_ext->drawIndirectCount = in_ext->drawIndirectCount; + out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; + out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; + out_ext->storagePushConstant8 = in_ext->storagePushConstant8; + out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; + out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; + out_ext->shaderFloat16 = in_ext->shaderFloat16; + out_ext->shaderInt8 = in_ext->shaderInt8; + out_ext->descriptorIndexing = in_ext->descriptorIndexing; + out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; + out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; + out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; + out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; + out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; + out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; + out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; + out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; + out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; + out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; + out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; + out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; + out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; + out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; + out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; + out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; + out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; + out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; + out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; + out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; + out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax; + out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; + out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; + out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; + out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; + out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; + out_ext->hostQueryReset = in_ext->hostQueryReset; + out_ext->timelineSemaphore = in_ext->timelineSemaphore; + out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; + out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; + out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; + out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; + out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; + out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; + out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex; + out_ext->shaderOutputLayer = in_ext->shaderOutputLayer; + out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceFormatPackFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceFormatPackFeaturesARM32 *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; + VkPhysicalDeviceVulkan13Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkan13Features32 *in_ext = (const VkPhysicalDeviceVulkan13Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; out_ext->pNext = NULL; - out_ext->formatPack = in_ext->formatPack; + out_ext->robustImageAccess = in_ext->robustImageAccess; + out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; + out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; + out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; + out_ext->privateData = in_ext->privateData; + out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; + out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; + out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; + out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; + out_ext->synchronization2 = in_ext->synchronization2; + out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; + out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; + out_ext->dynamicRendering = in_ext->dynamicRendering; + out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; + out_ext->maintenance4 = in_ext->maintenance4; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: { - VkPhysicalDeviceTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceTensorFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; + VkPhysicalDeviceVulkan14Features *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkan14Features32 *in_ext = (const VkPhysicalDeviceVulkan14Features32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; out_ext->pNext = NULL; - out_ext->tensorNonPacked = in_ext->tensorNonPacked; - out_ext->shaderTensorAccess = in_ext->shaderTensorAccess; - out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing; - out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing; - out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind; - out_ext->tensors = in_ext->tensors; + out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; + out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; + out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; + out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; + out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; + out_ext->rectangularLines = in_ext->rectangularLines; + out_ext->bresenhamLines = in_ext->bresenhamLines; + out_ext->smoothLines = in_ext->smoothLines; + out_ext->stippledRectangularLines = in_ext->stippledRectangularLines; + out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines; + out_ext->stippledSmoothLines = in_ext->stippledSmoothLines; + out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; + out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; + out_ext->indexTypeUint8 = in_ext->indexTypeUint8; + out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; + out_ext->maintenance5 = in_ext->maintenance5; + out_ext->maintenance6 = in_ext->maintenance6; + out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; + out_ext->pipelineRobustness = in_ext->pipelineRobustness; + out_ext->hostImageCopy = in_ext->hostImageCopy; + out_ext->pushDescriptor = in_ext->pushDescriptor; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: { - VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; + VkPhysicalDeviceVulkanMemoryModelFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceVulkanMemoryModelFeatures32 *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; out_ext->pNext = NULL; - out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors; + out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; + out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; + out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: { - VkPhysicalDeviceShaderFloat8FeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; + VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; out_ext->pNext = NULL; - out_ext->shaderFloat8 = in_ext->shaderFloat8; - out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix; + out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout; + out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout; + out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess; + out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: { - VkPhysicalDeviceDataGraphFeaturesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDataGraphFeaturesARM32 *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; + VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->dataGraph = in_ext->dataGraph; - out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind; - out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants; - out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer; - out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule; + out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: { - VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; + VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; out_ext->pNext = NULL; - out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode; + out_ext->ycbcrDegamma = in_ext->ycbcrDegamma; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: { - VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; + VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; out_ext->pNext = NULL; - out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers; + out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: + { + VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; + out_ext->pNext = NULL; + out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + { + VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; + out_ext->pNext = NULL; + out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -31429,555 +31429,609 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: { - VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV); - const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; - out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; + VkPhysicalDevice16BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES); + const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; + out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; + out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; + out_ext->storagePushConstant16 = in_ext->storagePushConstant16; + out_ext->storageInputOutput16 = in_ext->storageInputOutput16; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: { - VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV); - const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; - out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute; - out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines; - out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay; + VkPhysicalDevice4444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT); + const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; + out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4; + out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: { - VkPhysicalDevicePrivateDataFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES); - const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; - out_ext->privateData = in_ext->privateData; + VkPhysicalDevice8BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES); + const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; + out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; + out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; + out_ext->storagePushConstant8 = in_ext->storagePushConstant8; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: { - VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV); - const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; - out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure; + VkPhysicalDeviceASTCDecodeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT); + const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; + out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: { - VkPhysicalDeviceVariablePointersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES); - const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; - out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; - out_ext->variablePointers = in_ext->variablePointers; + VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR); + const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; + out_ext->accelerationStructure = in_ext->accelerationStructure; + out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay; + out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild; + out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands; + out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: { - VkPhysicalDeviceMultiviewFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES); - const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; - out_ext->multiview = in_ext->multiview; - out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; - out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; + VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT); + const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; + out_ext->reportAddressBinding = in_ext->reportAddressBinding; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: { - VkPhysicalDevicePresentIdFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR); - const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; - out_ext->presentId = in_ext->presentId; + VkPhysicalDeviceAntiLagFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD); + const VkPhysicalDeviceAntiLagFeaturesAMD *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; + out_ext->antiLag = in_ext->antiLag; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: { - VkPhysicalDevicePresentId2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR); - const VkPhysicalDevicePresentId2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; - out_ext->presentId2 = in_ext->presentId2; + VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT); + const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; + out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: { - VkPhysicalDevicePresentWaitFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR); - const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; - out_ext->presentWait = in_ext->presentWait; + VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT); + const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; + out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: { - VkPhysicalDevicePresentWait2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR); - const VkPhysicalDevicePresentWait2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; - out_ext->presentWait2 = in_ext->presentWait2; + VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT); + const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; + out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: { - VkPhysicalDevice16BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES); - const VkPhysicalDevice16BitStorageFeatures *in_ext = (const VkPhysicalDevice16BitStorageFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES; - out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; - out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; - out_ext->storagePushConstant16 = in_ext->storagePushConstant16; - out_ext->storageInputOutput16 = in_ext->storageInputOutput16; + VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT); + const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; + out_ext->borderColorSwizzle = in_ext->borderColorSwizzle; + out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: { - VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES); - const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; - out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; + VkPhysicalDeviceBufferDeviceAddressFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES); + const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; + out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; + out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; + out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: { - VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES); - const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; - out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; + VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT); + const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; + out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; + out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; + out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: { - VkPhysicalDeviceProtectedMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES); - const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; - out_ext->protectedMemory = in_ext->protectedMemory; + VkPhysicalDeviceClusterAccelerationStructureFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV); + const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDeviceClusterAccelerationStructureFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV; + out_ext->clusterAccelerationStructure = in_ext->clusterAccelerationStructure; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: { - VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT); - const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT; - out_ext->advancedBlendCoherentOperations = in_ext->advancedBlendCoherentOperations; + VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI); + const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI; + out_ext->clustercullingShader = in_ext->clustercullingShader; + out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: { - VkPhysicalDeviceMultiDrawFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT); - const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; - out_ext->multiDraw = in_ext->multiDraw; + VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD); + const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; + out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: { - VkPhysicalDeviceInlineUniformBlockFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES); - const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; - out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; - out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; + VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT); + const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; + out_ext->colorWriteEnable = in_ext->colorWriteEnable; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: { - VkPhysicalDeviceMaintenance4Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES); - const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; - out_ext->maintenance4 = in_ext->maintenance4; + VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV); + const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; + out_ext->commandBufferInheritance = in_ext->commandBufferInheritance; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: { - VkPhysicalDeviceMaintenance5Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES); - const VkPhysicalDeviceMaintenance5Features *in_ext = (const VkPhysicalDeviceMaintenance5Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; - out_ext->maintenance5 = in_ext->maintenance5; + VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR); + const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; + out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads; + out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: { - VkPhysicalDeviceMaintenance6Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES); - const VkPhysicalDeviceMaintenance6Features *in_ext = (const VkPhysicalDeviceMaintenance6Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; - out_ext->maintenance6 = in_ext->maintenance6; + VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT); + const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; + out_ext->conditionalRendering = in_ext->conditionalRendering; + out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: { - VkPhysicalDeviceMaintenance8FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR); - const VkPhysicalDeviceMaintenance8FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; - out_ext->maintenance8 = in_ext->maintenance8; + VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV); + const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; + out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope; + out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions; + out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions; + out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions; + out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations; + out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing; + out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: { - VkPhysicalDeviceMaintenance9FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR); - const VkPhysicalDeviceMaintenance9FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; - out_ext->maintenance9 = in_ext->maintenance9; + VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR); + const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; + out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; + out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: { - VkPhysicalDeviceShaderDrawParametersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES); - const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; - out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; + VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV); + const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; + out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; + out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: { - VkPhysicalDeviceShaderFloat16Int8Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES); - const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; - out_ext->shaderFloat16 = in_ext->shaderFloat16; - out_ext->shaderInt8 = in_ext->shaderInt8; + VkPhysicalDeviceCooperativeVectorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV); + const VkPhysicalDeviceCooperativeVectorFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; + out_ext->cooperativeVector = in_ext->cooperativeVector; + out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: { - VkPhysicalDeviceHostQueryResetFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES); - const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; - out_ext->hostQueryReset = in_ext->hostQueryReset; - out_header = (void *)out_ext; + VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV); + const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; + out_ext->indirectCopy = in_ext->indirectCopy; + out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: { - VkPhysicalDeviceGlobalPriorityQueryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES); - const VkPhysicalDeviceGlobalPriorityQueryFeatures *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; - out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; + VkPhysicalDeviceCornerSampledImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV); + const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; + out_ext->cornerSampledImage = in_ext->cornerSampledImage; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: { - VkPhysicalDeviceDescriptorIndexingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES); - const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; - out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; - out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; - out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; - out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; - out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; - out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; - out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; - out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; - out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; - out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; - out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; - out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; - out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; - out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; - out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; - out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; - out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; - out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; - out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; - out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; + VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV); + const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; + out_ext->coverageReductionMode = in_ext->coverageReductionMode; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: { - VkPhysicalDeviceTimelineSemaphoreFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES); - const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; - out_ext->timelineSemaphore = in_ext->timelineSemaphore; + VkPhysicalDeviceCubicClampFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM); + const VkPhysicalDeviceCubicClampFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; + out_ext->cubicRangeClamp = in_ext->cubicRangeClamp; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: { - VkPhysicalDevice8BitStorageFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES); - const VkPhysicalDevice8BitStorageFeatures *in_ext = (const VkPhysicalDevice8BitStorageFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES; - out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; - out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; - out_ext->storagePushConstant8 = in_ext->storagePushConstant8; + VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM); + const VkPhysicalDeviceCubicWeightsFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; + out_ext->selectableCubicWeights = in_ext->selectableCubicWeights; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: { - VkPhysicalDeviceConditionalRenderingFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT); - const VkPhysicalDeviceConditionalRenderingFeaturesEXT *in_ext = (const VkPhysicalDeviceConditionalRenderingFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT; - out_ext->conditionalRendering = in_ext->conditionalRendering; - out_ext->inheritedConditionalRendering = in_ext->inheritedConditionalRendering; + VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT); + const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; + out_ext->customBorderColors = in_ext->customBorderColors; + out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: { - VkPhysicalDeviceVulkanMemoryModelFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES); - const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; - out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; - out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; - out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; + VkPhysicalDeviceDataGraphFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM); + const VkPhysicalDeviceDataGraphFeaturesARM *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; + out_ext->dataGraph = in_ext->dataGraph; + out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind; + out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants; + out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer; + out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: { - VkPhysicalDeviceShaderAtomicInt64Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES); - const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; - out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; - out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; + VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV); + const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; + out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT); - const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; - out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics; - out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd; - out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics; - out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd; - out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics; - out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd; - out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics; - out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd; - out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics; - out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd; - out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics; - out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd; + VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT); + const VkPhysicalDeviceDepthBiasControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; + out_ext->depthBiasControl = in_ext->depthBiasControl; + out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation; + out_ext->floatRepresentation = in_ext->floatRepresentation; + out_ext->depthBiasExact = in_ext->depthBiasExact; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT); - const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; - out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics; - out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd; - out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax; - out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax; - out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax; - out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics; - out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd; - out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax; - out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax; - out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax; - out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax; - out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax; + VkPhysicalDeviceDepthClampControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT); + const VkPhysicalDeviceDepthClampControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; + out_ext->depthClampControl = in_ext->depthClampControl; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: { - VkPhysicalDeviceVertexAttributeDivisorFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES); - const VkPhysicalDeviceVertexAttributeDivisorFeatures *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; - out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; - out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; + VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR); + const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; + out_ext->depthClampZeroOne = in_ext->depthClampZeroOne; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: { - VkPhysicalDeviceASTCDecodeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT); - const VkPhysicalDeviceASTCDecodeFeaturesEXT *in_ext = (const VkPhysicalDeviceASTCDecodeFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT; - out_ext->decodeModeSharedExponent = in_ext->decodeModeSharedExponent; + VkPhysicalDeviceDepthClipControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT); + const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; + out_ext->depthClipControl = in_ext->depthClipControl; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: { - VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT); - const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; - out_ext->transformFeedback = in_ext->transformFeedback; - out_ext->geometryStreams = in_ext->geometryStreams; + VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT); + const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; + out_ext->depthClipEnable = in_ext->depthClipEnable; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: { - VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV); - const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; - out_ext->representativeFragmentTest = in_ext->representativeFragmentTest; + VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT); + const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; + out_ext->descriptorBuffer = in_ext->descriptorBuffer; + out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay; + out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored; + out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: { - VkPhysicalDeviceExclusiveScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV); - const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; - out_ext->exclusiveScissor = in_ext->exclusiveScissor; + VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM); + const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; + out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: { - VkPhysicalDeviceCornerSampledImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV); - const VkPhysicalDeviceCornerSampledImageFeaturesNV *in_ext = (const VkPhysicalDeviceCornerSampledImageFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV; - out_ext->cornerSampledImage = in_ext->cornerSampledImage; + VkPhysicalDeviceDescriptorIndexingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES); + const VkPhysicalDeviceDescriptorIndexingFeatures *in_ext = (const VkPhysicalDeviceDescriptorIndexingFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES; + out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; + out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; + out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; + out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; + out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; + out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; + out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; + out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; + out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; + out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; + out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; + out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; + out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; + out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; + out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; + out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; + out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; + out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; + out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; + out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: { - VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR); - const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR; - out_ext->computeDerivativeGroupQuads = in_ext->computeDerivativeGroupQuads; - out_ext->computeDerivativeGroupLinear = in_ext->computeDerivativeGroupLinear; + VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV); + const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; + out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: { - VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV); - const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; - out_ext->imageFootprint = in_ext->imageFootprint; + VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE); + const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; + out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: { - VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV); - const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *in_ext = (const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV; - out_ext->dedicatedAllocationImageAliasing = in_ext->dedicatedAllocationImageAliasing; + VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV); + const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV; + out_ext->deviceGeneratedCompute = in_ext->deviceGeneratedCompute; + out_ext->deviceGeneratedComputePipelines = in_ext->deviceGeneratedComputePipelines; + out_ext->deviceGeneratedComputeCaptureReplay = in_ext->deviceGeneratedComputeCaptureReplay; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: { - VkPhysicalDeviceCopyMemoryIndirectFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV); - const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV; - out_ext->indirectCopy = in_ext->indirectCopy; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT); + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; + out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; + out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: { - VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV); - const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; - out_ext->memoryDecompression = in_ext->memoryDecompression; + VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV); + const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV; + out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: { - VkPhysicalDeviceShadingRateImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV); - const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; - out_ext->shadingRateImage = in_ext->shadingRateImage; - out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder; + VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV); + const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; + out_ext->diagnosticsConfig = in_ext->diagnosticsConfig; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: { - VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI); - const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; - out_ext->invocationMask = in_ext->invocationMask; + VkPhysicalDeviceDynamicRenderingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES); + const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; + out_ext->dynamicRendering = in_ext->dynamicRendering; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: { - VkPhysicalDeviceMeshShaderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV); - const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; - out_ext->taskShader = in_ext->taskShader; - out_ext->meshShader = in_ext->meshShader; + VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES); + const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; + out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: { - VkPhysicalDeviceMeshShaderFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT); - const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; - out_ext->taskShader = in_ext->taskShader; - out_ext->meshShader = in_ext->meshShader; - out_ext->multiviewMeshShader = in_ext->multiviewMeshShader; - out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader; - out_ext->meshShaderQueries = in_ext->meshShaderQueries; + VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT); + const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; + out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: { - VkPhysicalDeviceAccelerationStructureFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR); - const VkPhysicalDeviceAccelerationStructureFeaturesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructureFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR; - out_ext->accelerationStructure = in_ext->accelerationStructure; - out_ext->accelerationStructureCaptureReplay = in_ext->accelerationStructureCaptureReplay; - out_ext->accelerationStructureIndirectBuild = in_ext->accelerationStructureIndirectBuild; - out_ext->accelerationStructureHostCommands = in_ext->accelerationStructureHostCommands; - out_ext->descriptorBindingAccelerationStructureUpdateAfterBind = in_ext->descriptorBindingAccelerationStructureUpdateAfterBind; + VkPhysicalDeviceExclusiveScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV); + const VkPhysicalDeviceExclusiveScissorFeaturesNV *in_ext = (const VkPhysicalDeviceExclusiveScissorFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV; + out_ext->exclusiveScissor = in_ext->exclusiveScissor; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: { - VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR); - const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; - out_ext->rayTracingPipeline = in_ext->rayTracingPipeline; - out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay; - out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed; - out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect; - out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling; + VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT); + const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; + out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2; + out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp; + out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: { - VkPhysicalDeviceRayQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR); - const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; - out_ext->rayQuery = in_ext->rayQuery; + VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT); + const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; + out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin; + out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable; + out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode; + out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples; + out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask; + out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable; + out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable; + out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable; + out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable; + out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation; + out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask; + out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream; + out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode; + out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize; + out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable; + out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable; + out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced; + out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode; + out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode; + out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable; + out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne; + out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable; + out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle; + out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable; + out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation; + out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode; + out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable; + out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable; + out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode; + out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable; + out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: { - VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR); - const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; - out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1; - out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2; + VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT); + const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; + out_ext->extendedDynamicState = in_ext->extendedDynamicState; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: + { + VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV); + const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; + out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: + { + VkPhysicalDeviceFaultFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT); + const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; + out_ext->deviceFault = in_ext->deviceFault; + out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: + { + VkPhysicalDeviceFormatPackFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM); + const VkPhysicalDeviceFormatPackFeaturesARM *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; + out_ext->formatPack = in_ext->formatPack; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: + { + VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT); + const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; + out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred; out_header = (void *)out_ext; break; } @@ -31992,12 +32046,12 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: { - VkPhysicalDeviceFragmentDensityMap2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT); - const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT; - out_ext->fragmentDensityMapDeferred = in_ext->fragmentDensityMapDeferred; + VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE); + const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *in_ext = (const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; + out_ext->fragmentDensityMapLayered = in_ext->fragmentDensityMapLayered; out_header = (void *)out_ext; break; } @@ -32010,239 +32064,247 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: { - VkPhysicalDeviceScalarBlockLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES); - const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; - out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; + VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR); + const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; + out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: { - VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES); - const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; - out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; + VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT); + const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; + out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock; + out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock; + out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: { - VkPhysicalDeviceDepthClipEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT); - const VkPhysicalDeviceDepthClipEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipEnableFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT; - out_ext->depthClipEnable = in_ext->depthClipEnable; + VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV); + const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; + out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums; + out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates; + out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: { - VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT); - const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; - out_ext->memoryPriority = in_ext->memoryPriority; + VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR); + const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; + out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate; + out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate; + out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: { - VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT); - const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; - out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory; + VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT); + const VkPhysicalDeviceFrameBoundaryFeaturesEXT *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; + out_ext->frameBoundary = in_ext->frameBoundary; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: { - VkPhysicalDeviceBufferDeviceAddressFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES); - const VkPhysicalDeviceBufferDeviceAddressFeatures *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES; - out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; - out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; - out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; + VkPhysicalDeviceGlobalPriorityQueryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES); + const VkPhysicalDeviceGlobalPriorityQueryFeatures *in_ext = (const VkPhysicalDeviceGlobalPriorityQueryFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES; + out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: { - VkPhysicalDeviceBufferDeviceAddressFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT); - const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *in_ext = (const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT; - out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; - out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; - out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; + VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT); + const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; + out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: { - VkPhysicalDeviceImagelessFramebufferFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES); - const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; - out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; + VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI); + const VkPhysicalDeviceHdrVividFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; + out_ext->hdrVivid = in_ext->hdrVivid; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: { - VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES); - const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; - out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; + VkPhysicalDeviceHostImageCopyFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES); + const VkPhysicalDeviceHostImageCopyFeatures *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; + out_ext->hostImageCopy = in_ext->hostImageCopy; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: { - VkPhysicalDeviceCooperativeMatrixFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV); - const VkPhysicalDeviceCooperativeMatrixFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV; - out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; - out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; + VkPhysicalDeviceHostQueryResetFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES); + const VkPhysicalDeviceHostQueryResetFeatures *in_ext = (const VkPhysicalDeviceHostQueryResetFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES; + out_ext->hostQueryReset = in_ext->hostQueryReset; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: { - VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT); - const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; - out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays; + VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT); + const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; + out_ext->image2DViewOf3D = in_ext->image2DViewOf3D; + out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: { - VkPhysicalDevicePresentBarrierFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV); - const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; - out_ext->presentBarrier = in_ext->presentBarrier; + VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA); + const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; + out_ext->imageAlignmentControl = in_ext->imageAlignmentControl; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: { - VkPhysicalDevicePerformanceQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR); - const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; - out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools; - out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools; + VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT); + const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; + out_ext->imageCompressionControl = in_ext->imageCompressionControl; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: { - VkPhysicalDeviceCoverageReductionModeFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV); - const VkPhysicalDeviceCoverageReductionModeFeaturesNV *in_ext = (const VkPhysicalDeviceCoverageReductionModeFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV; - out_ext->coverageReductionMode = in_ext->coverageReductionMode; + VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT); + const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; + out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: { - VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL); - const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; - out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2; + VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM); + const VkPhysicalDeviceImageProcessing2FeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; + out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: { - VkPhysicalDeviceShaderClockFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR); - const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; - out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock; - out_ext->shaderDeviceClock = in_ext->shaderDeviceClock; + VkPhysicalDeviceImageProcessingFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM); + const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; + out_ext->textureSampleWeighted = in_ext->textureSampleWeighted; + out_ext->textureBoxFilter = in_ext->textureBoxFilter; + out_ext->textureBlockMatch = in_ext->textureBlockMatch; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: { - VkPhysicalDeviceIndexTypeUint8Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES); - const VkPhysicalDeviceIndexTypeUint8Features *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; - out_ext->indexTypeUint8 = in_ext->indexTypeUint8; + VkPhysicalDeviceImageRobustnessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES); + const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; + out_ext->robustImageAccess = in_ext->robustImageAccess; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: { - VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV); - const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; - out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins; + VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT); + const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; + out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: { - VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT); - const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *in_ext = (const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT; - out_ext->fragmentShaderSampleInterlock = in_ext->fragmentShaderSampleInterlock; - out_ext->fragmentShaderPixelInterlock = in_ext->fragmentShaderPixelInterlock; - out_ext->fragmentShaderShadingRateInterlock = in_ext->fragmentShaderShadingRateInterlock; + VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT); + const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; + out_ext->minLod = in_ext->minLod; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: { - VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES); - const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; - out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; + VkPhysicalDeviceImagelessFramebufferFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES); + const VkPhysicalDeviceImagelessFramebufferFeatures *in_ext = (const VkPhysicalDeviceImagelessFramebufferFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES; + out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: { - VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT); - const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; - out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart; - out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart; + VkPhysicalDeviceIndexTypeUint8Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES); + const VkPhysicalDeviceIndexTypeUint8Features *in_ext = (const VkPhysicalDeviceIndexTypeUint8Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES; + out_ext->indexTypeUint8 = in_ext->indexTypeUint8; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: { - VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR); - const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; - out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo; + VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV); + const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; + out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: { - VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES); - const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; - out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; + VkPhysicalDeviceInlineUniformBlockFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES); + const VkPhysicalDeviceInlineUniformBlockFeatures *in_ext = (const VkPhysicalDeviceInlineUniformBlockFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES; + out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; + out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: { - VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT); - const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; - out_ext->texelBufferAlignment = in_ext->texelBufferAlignment; + VkPhysicalDeviceInvocationMaskFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI); + const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI; + out_ext->invocationMask = in_ext->invocationMask; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: { - VkPhysicalDeviceSubgroupSizeControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES); - const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; - out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; - out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; + VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT); + const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; + out_ext->legacyDithering = in_ext->legacyDithering; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: + { + VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT); + const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; + out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes; out_header = (void *)out_ext; break; } @@ -32260,654 +32322,526 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: { - VkPhysicalDevicePipelineCreationCacheControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES); - const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; - out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; + VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV); + const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; + out_ext->linearColorAttachment = in_ext->linearColorAttachment; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: { - VkPhysicalDeviceVulkan11Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES); - const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; - out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; - out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; - out_ext->storagePushConstant16 = in_ext->storagePushConstant16; - out_ext->storageInputOutput16 = in_ext->storageInputOutput16; - out_ext->multiview = in_ext->multiview; - out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; - out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; - out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; - out_ext->variablePointers = in_ext->variablePointers; - out_ext->protectedMemory = in_ext->protectedMemory; - out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; - out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: - { - VkPhysicalDeviceVulkan12Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES); - const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; - out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge; - out_ext->drawIndirectCount = in_ext->drawIndirectCount; - out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; - out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; - out_ext->storagePushConstant8 = in_ext->storagePushConstant8; - out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; - out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; - out_ext->shaderFloat16 = in_ext->shaderFloat16; - out_ext->shaderInt8 = in_ext->shaderInt8; - out_ext->descriptorIndexing = in_ext->descriptorIndexing; - out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; - out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; - out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; - out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; - out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; - out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; - out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; - out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; - out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; - out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; - out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; - out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; - out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; - out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; - out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; - out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; - out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; - out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; - out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; - out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; - out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax; - out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; - out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; - out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; - out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; - out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; - out_ext->hostQueryReset = in_ext->hostQueryReset; - out_ext->timelineSemaphore = in_ext->timelineSemaphore; - out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; - out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; - out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; - out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; - out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; - out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; - out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex; - out_ext->shaderOutputLayer = in_ext->shaderOutputLayer; - out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId; + VkPhysicalDeviceMaintenance4Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES); + const VkPhysicalDeviceMaintenance4Features *in_ext = (const VkPhysicalDeviceMaintenance4Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES; + out_ext->maintenance4 = in_ext->maintenance4; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: { - VkPhysicalDeviceVulkan13Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES); - const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; - out_ext->robustImageAccess = in_ext->robustImageAccess; - out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; - out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; - out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; - out_ext->privateData = in_ext->privateData; - out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; - out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; - out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; - out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; - out_ext->synchronization2 = in_ext->synchronization2; - out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; - out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; - out_ext->dynamicRendering = in_ext->dynamicRendering; - out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; - out_ext->maintenance4 = in_ext->maintenance4; + VkPhysicalDeviceMaintenance5Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES); + const VkPhysicalDeviceMaintenance5Features *in_ext = (const VkPhysicalDeviceMaintenance5Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES; + out_ext->maintenance5 = in_ext->maintenance5; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: { - VkPhysicalDeviceVulkan14Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES); - const VkPhysicalDeviceVulkan14Features *in_ext = (const VkPhysicalDeviceVulkan14Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; - out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; - out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; - out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; - out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; - out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; - out_ext->rectangularLines = in_ext->rectangularLines; - out_ext->bresenhamLines = in_ext->bresenhamLines; - out_ext->smoothLines = in_ext->smoothLines; - out_ext->stippledRectangularLines = in_ext->stippledRectangularLines; - out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines; - out_ext->stippledSmoothLines = in_ext->stippledSmoothLines; - out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; - out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; - out_ext->indexTypeUint8 = in_ext->indexTypeUint8; - out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; - out_ext->maintenance5 = in_ext->maintenance5; + VkPhysicalDeviceMaintenance6Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES); + const VkPhysicalDeviceMaintenance6Features *in_ext = (const VkPhysicalDeviceMaintenance6Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES; out_ext->maintenance6 = in_ext->maintenance6; - out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; - out_ext->pipelineRobustness = in_ext->pipelineRobustness; - out_ext->hostImageCopy = in_ext->hostImageCopy; - out_ext->pushDescriptor = in_ext->pushDescriptor; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: { - VkPhysicalDeviceCoherentMemoryFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD); - const VkPhysicalDeviceCoherentMemoryFeaturesAMD *in_ext = (const VkPhysicalDeviceCoherentMemoryFeaturesAMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD; - out_ext->deviceCoherentMemory = in_ext->deviceCoherentMemory; + VkPhysicalDeviceMaintenance8FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR); + const VkPhysicalDeviceMaintenance8FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance8FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR; + out_ext->maintenance8 = in_ext->maintenance8; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: { - VkPhysicalDeviceCustomBorderColorFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT); - const VkPhysicalDeviceCustomBorderColorFeaturesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT; - out_ext->customBorderColors = in_ext->customBorderColors; - out_ext->customBorderColorWithoutFormat = in_ext->customBorderColorWithoutFormat; + VkPhysicalDeviceMaintenance9FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR); + const VkPhysicalDeviceMaintenance9FeaturesKHR *in_ext = (const VkPhysicalDeviceMaintenance9FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR; + out_ext->maintenance9 = in_ext->maintenance9; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: { - VkPhysicalDeviceBorderColorSwizzleFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT); - const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *in_ext = (const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT; - out_ext->borderColorSwizzle = in_ext->borderColorSwizzle; - out_ext->borderColorSwizzleFromImage = in_ext->borderColorSwizzleFromImage; + VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT); + const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; + out_ext->memoryMapPlaced = in_ext->memoryMapPlaced; + out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced; + out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: { - VkPhysicalDeviceExtendedDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT); - const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT; - out_ext->extendedDynamicState = in_ext->extendedDynamicState; + VkPhysicalDeviceMemoryDecompressionFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV); + const VkPhysicalDeviceMemoryDecompressionFeaturesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV; + out_ext->memoryDecompression = in_ext->memoryDecompression; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: { - VkPhysicalDeviceExtendedDynamicState2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT); - const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT; - out_ext->extendedDynamicState2 = in_ext->extendedDynamicState2; - out_ext->extendedDynamicState2LogicOp = in_ext->extendedDynamicState2LogicOp; - out_ext->extendedDynamicState2PatchControlPoints = in_ext->extendedDynamicState2PatchControlPoints; + VkPhysicalDeviceMemoryPriorityFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT); + const VkPhysicalDeviceMemoryPriorityFeaturesEXT *in_ext = (const VkPhysicalDeviceMemoryPriorityFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT; + out_ext->memoryPriority = in_ext->memoryPriority; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: { - VkPhysicalDeviceExtendedDynamicState3FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT); - const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT; - out_ext->extendedDynamicState3TessellationDomainOrigin = in_ext->extendedDynamicState3TessellationDomainOrigin; - out_ext->extendedDynamicState3DepthClampEnable = in_ext->extendedDynamicState3DepthClampEnable; - out_ext->extendedDynamicState3PolygonMode = in_ext->extendedDynamicState3PolygonMode; - out_ext->extendedDynamicState3RasterizationSamples = in_ext->extendedDynamicState3RasterizationSamples; - out_ext->extendedDynamicState3SampleMask = in_ext->extendedDynamicState3SampleMask; - out_ext->extendedDynamicState3AlphaToCoverageEnable = in_ext->extendedDynamicState3AlphaToCoverageEnable; - out_ext->extendedDynamicState3AlphaToOneEnable = in_ext->extendedDynamicState3AlphaToOneEnable; - out_ext->extendedDynamicState3LogicOpEnable = in_ext->extendedDynamicState3LogicOpEnable; - out_ext->extendedDynamicState3ColorBlendEnable = in_ext->extendedDynamicState3ColorBlendEnable; - out_ext->extendedDynamicState3ColorBlendEquation = in_ext->extendedDynamicState3ColorBlendEquation; - out_ext->extendedDynamicState3ColorWriteMask = in_ext->extendedDynamicState3ColorWriteMask; - out_ext->extendedDynamicState3RasterizationStream = in_ext->extendedDynamicState3RasterizationStream; - out_ext->extendedDynamicState3ConservativeRasterizationMode = in_ext->extendedDynamicState3ConservativeRasterizationMode; - out_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize = in_ext->extendedDynamicState3ExtraPrimitiveOverestimationSize; - out_ext->extendedDynamicState3DepthClipEnable = in_ext->extendedDynamicState3DepthClipEnable; - out_ext->extendedDynamicState3SampleLocationsEnable = in_ext->extendedDynamicState3SampleLocationsEnable; - out_ext->extendedDynamicState3ColorBlendAdvanced = in_ext->extendedDynamicState3ColorBlendAdvanced; - out_ext->extendedDynamicState3ProvokingVertexMode = in_ext->extendedDynamicState3ProvokingVertexMode; - out_ext->extendedDynamicState3LineRasterizationMode = in_ext->extendedDynamicState3LineRasterizationMode; - out_ext->extendedDynamicState3LineStippleEnable = in_ext->extendedDynamicState3LineStippleEnable; - out_ext->extendedDynamicState3DepthClipNegativeOneToOne = in_ext->extendedDynamicState3DepthClipNegativeOneToOne; - out_ext->extendedDynamicState3ViewportWScalingEnable = in_ext->extendedDynamicState3ViewportWScalingEnable; - out_ext->extendedDynamicState3ViewportSwizzle = in_ext->extendedDynamicState3ViewportSwizzle; - out_ext->extendedDynamicState3CoverageToColorEnable = in_ext->extendedDynamicState3CoverageToColorEnable; - out_ext->extendedDynamicState3CoverageToColorLocation = in_ext->extendedDynamicState3CoverageToColorLocation; - out_ext->extendedDynamicState3CoverageModulationMode = in_ext->extendedDynamicState3CoverageModulationMode; - out_ext->extendedDynamicState3CoverageModulationTableEnable = in_ext->extendedDynamicState3CoverageModulationTableEnable; - out_ext->extendedDynamicState3CoverageModulationTable = in_ext->extendedDynamicState3CoverageModulationTable; - out_ext->extendedDynamicState3CoverageReductionMode = in_ext->extendedDynamicState3CoverageReductionMode; - out_ext->extendedDynamicState3RepresentativeFragmentTestEnable = in_ext->extendedDynamicState3RepresentativeFragmentTestEnable; - out_ext->extendedDynamicState3ShadingRateImageEnable = in_ext->extendedDynamicState3ShadingRateImageEnable; + VkPhysicalDeviceMeshShaderFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT); + const VkPhysicalDeviceMeshShaderFeaturesEXT *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT; + out_ext->taskShader = in_ext->taskShader; + out_ext->meshShader = in_ext->meshShader; + out_ext->multiviewMeshShader = in_ext->multiviewMeshShader; + out_ext->primitiveFragmentShadingRateMeshShader = in_ext->primitiveFragmentShadingRateMeshShader; + out_ext->meshShaderQueries = in_ext->meshShaderQueries; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: { - VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV); - const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; - out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure; + VkPhysicalDeviceMeshShaderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV); + const VkPhysicalDeviceMeshShaderFeaturesNV *in_ext = (const VkPhysicalDeviceMeshShaderFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV; + out_ext->taskShader = in_ext->taskShader; + out_ext->meshShader = in_ext->meshShader; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: { - VkPhysicalDeviceDiagnosticsConfigFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV); - const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *in_ext = (const VkPhysicalDeviceDiagnosticsConfigFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV; - out_ext->diagnosticsConfig = in_ext->diagnosticsConfig; + VkPhysicalDeviceMultiDrawFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT); + const VkPhysicalDeviceMultiDrawFeaturesEXT *in_ext = (const VkPhysicalDeviceMultiDrawFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT; + out_ext->multiDraw = in_ext->multiDraw; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: { - VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES); - const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; - out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; + VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT); + const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; + out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: { - VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR); - const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; - out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow; + VkPhysicalDeviceMultiviewFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES); + const VkPhysicalDeviceMultiviewFeatures *in_ext = (const VkPhysicalDeviceMultiviewFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES; + out_ext->multiview = in_ext->multiview; + out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; + out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: { - VkPhysicalDeviceRobustness2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR); - const VkPhysicalDeviceRobustness2FeaturesKHR *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; - out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2; - out_ext->robustImageAccess2 = in_ext->robustImageAccess2; - out_ext->nullDescriptor = in_ext->nullDescriptor; + VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM); + const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM; + out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: { - VkPhysicalDeviceImageRobustnessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES); - const VkPhysicalDeviceImageRobustnessFeatures *in_ext = (const VkPhysicalDeviceImageRobustnessFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES; - out_ext->robustImageAccess = in_ext->robustImageAccess; + VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM); + const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; + out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: { - VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR); - const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; - out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout; - out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout; - out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess; - out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess; + VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT); + const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; + out_ext->mutableDescriptorType = in_ext->mutableDescriptorType; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: { - VkPhysicalDevice4444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT); - const VkPhysicalDevice4444FormatsFeaturesEXT *in_ext = (const VkPhysicalDevice4444FormatsFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT; - out_ext->formatA4R4G4B4 = in_ext->formatA4R4G4B4; - out_ext->formatA4B4G4R4 = in_ext->formatA4B4G4R4; + VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT); + const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; + out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer; + out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering; + out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: { - VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI); - const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; - out_ext->subpassShading = in_ext->subpassShading; + VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT); + const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; + out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: { - VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI); - const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI; - out_ext->clustercullingShader = in_ext->clustercullingShader; - out_ext->multiviewClusterCullingShader = in_ext->multiviewClusterCullingShader; + VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT); + const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; + out_ext->micromap = in_ext->micromap; + out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay; + out_ext->micromapHostCommands = in_ext->micromapHostCommands; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: { - VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT); - const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; - out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics; - out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics; + VkPhysicalDeviceOpticalFlowFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV); + const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; + out_ext->opticalFlow = in_ext->opticalFlow; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: { - VkPhysicalDeviceFragmentShadingRateFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR); - const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRateFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR; - out_ext->pipelineFragmentShadingRate = in_ext->pipelineFragmentShadingRate; - out_ext->primitiveFragmentShadingRate = in_ext->primitiveFragmentShadingRate; - out_ext->attachmentFragmentShadingRate = in_ext->attachmentFragmentShadingRate; + VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT); + const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *in_ext = (const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT; + out_ext->pageableDeviceLocalMemory = in_ext->pageableDeviceLocalMemory; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: { - VkPhysicalDeviceShaderTerminateInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES); - const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; - out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; + VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV); + const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV; + out_ext->partitionedAccelerationStructure = in_ext->partitionedAccelerationStructure; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: { - VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV); - const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV; - out_ext->fragmentShadingRateEnums = in_ext->fragmentShadingRateEnums; - out_ext->supersampleFragmentShadingRates = in_ext->supersampleFragmentShadingRates; - out_ext->noInvocationFragmentShadingRates = in_ext->noInvocationFragmentShadingRates; + VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV); + const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; + out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet; + out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: { - VkPhysicalDeviceImage2DViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT); - const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT; - out_ext->image2DViewOf3D = in_ext->image2DViewOf3D; - out_ext->sampler2DViewOf3D = in_ext->sampler2DViewOf3D; + VkPhysicalDevicePerformanceQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR); + const VkPhysicalDevicePerformanceQueryFeaturesKHR *in_ext = (const VkPhysicalDevicePerformanceQueryFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR; + out_ext->performanceCounterQueryPools = in_ext->performanceCounterQueryPools; + out_ext->performanceCounterMultipleQueryPools = in_ext->performanceCounterMultipleQueryPools; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: { - VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT); - const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *in_ext = (const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT; - out_ext->imageSlicedViewOf3D = in_ext->imageSlicedViewOf3D; + VkPhysicalDevicePipelineBinaryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR); + const VkPhysicalDevicePipelineBinaryFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; + out_ext->pipelineBinaries = in_ext->pipelineBinaries; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: { - VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT); - const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT; - out_ext->attachmentFeedbackLoopDynamicState = in_ext->attachmentFeedbackLoopDynamicState; + VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC); + const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; + out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: { - VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT); - const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT; - out_ext->legacyVertexAttributes = in_ext->legacyVertexAttributes; + VkPhysicalDevicePipelineCreationCacheControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES); + const VkPhysicalDevicePipelineCreationCacheControlFeatures *in_ext = (const VkPhysicalDevicePipelineCreationCacheControlFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES; + out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: { - VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT); - const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *in_ext = (const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT; - out_ext->mutableDescriptorType = in_ext->mutableDescriptorType; + VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR); + const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR; + out_ext->pipelineExecutableInfo = in_ext->pipelineExecutableInfo; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: { - VkPhysicalDeviceDepthClipControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT); - const VkPhysicalDeviceDepthClipControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClipControlFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT; - out_ext->depthClipControl = in_ext->depthClipControl; + VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT); + const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; + out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: { - VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT); - const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; - out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory; + VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM); + const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; + out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: { - VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT); - const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT; - out_ext->deviceGeneratedCommands = in_ext->deviceGeneratedCommands; - out_ext->dynamicGeneratedPipelineLayout = in_ext->dynamicGeneratedPipelineLayout; + VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT); + const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; + out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: { - VkPhysicalDeviceDepthClampControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT); - const VkPhysicalDeviceDepthClampControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthClampControlFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT; - out_ext->depthClampControl = in_ext->depthClampControl; + VkPhysicalDevicePipelineProtectedAccessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES); + const VkPhysicalDevicePipelineProtectedAccessFeatures *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; + out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: { - VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT); - const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; - out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState; + VkPhysicalDevicePipelineRobustnessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES); + const VkPhysicalDevicePipelineRobustnessFeatures *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; + out_ext->pipelineRobustness = in_ext->pipelineRobustness; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: { - VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR); - const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; - out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction; + VkPhysicalDevicePresentBarrierFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV); + const VkPhysicalDevicePresentBarrierFeaturesNV *in_ext = (const VkPhysicalDevicePresentBarrierFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV; + out_ext->presentBarrier = in_ext->presentBarrier; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: { - VkPhysicalDeviceColorWriteEnableFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT); - const VkPhysicalDeviceColorWriteEnableFeaturesEXT *in_ext = (const VkPhysicalDeviceColorWriteEnableFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT; - out_ext->colorWriteEnable = in_ext->colorWriteEnable; + VkPhysicalDevicePresentId2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR); + const VkPhysicalDevicePresentId2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentId2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR; + out_ext->presentId2 = in_ext->presentId2; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: { - VkPhysicalDeviceSynchronization2Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES); - const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; - out_ext->synchronization2 = in_ext->synchronization2; + VkPhysicalDevicePresentIdFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR); + const VkPhysicalDevicePresentIdFeaturesKHR *in_ext = (const VkPhysicalDevicePresentIdFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR; + out_ext->presentId = in_ext->presentId; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: { - VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR); - const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; - out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts; - out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo; + VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR); + const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; + out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: { - VkPhysicalDeviceHostImageCopyFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES); - const VkPhysicalDeviceHostImageCopyFeatures *in_ext = (const VkPhysicalDeviceHostImageCopyFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES; - out_ext->hostImageCopy = in_ext->hostImageCopy; + VkPhysicalDevicePresentWait2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR); + const VkPhysicalDevicePresentWait2FeaturesKHR *in_ext = (const VkPhysicalDevicePresentWait2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR; + out_ext->presentWait2 = in_ext->presentWait2; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: { - VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT); - const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; - out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery; - out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard; - out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams; + VkPhysicalDevicePresentWaitFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR); + const VkPhysicalDevicePresentWaitFeaturesKHR *in_ext = (const VkPhysicalDevicePresentWaitFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR; + out_ext->presentWait = in_ext->presentWait; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: { - VkPhysicalDeviceLegacyDitheringFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT); - const VkPhysicalDeviceLegacyDitheringFeaturesEXT *in_ext = (const VkPhysicalDeviceLegacyDitheringFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT; - out_ext->legacyDithering = in_ext->legacyDithering; + VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT); + const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT; + out_ext->primitiveTopologyListRestart = in_ext->primitiveTopologyListRestart; + out_ext->primitiveTopologyPatchListRestart = in_ext->primitiveTopologyPatchListRestart; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: { - VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT); - const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *in_ext = (const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT; - out_ext->multisampledRenderToSingleSampled = in_ext->multisampledRenderToSingleSampled; + VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT); + const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *in_ext = (const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT; + out_ext->primitivesGeneratedQuery = in_ext->primitivesGeneratedQuery; + out_ext->primitivesGeneratedQueryWithRasterizerDiscard = in_ext->primitivesGeneratedQueryWithRasterizerDiscard; + out_ext->primitivesGeneratedQueryWithNonZeroStreams = in_ext->primitivesGeneratedQueryWithNonZeroStreams; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: { - VkPhysicalDevicePipelineProtectedAccessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES); - const VkPhysicalDevicePipelineProtectedAccessFeatures *in_ext = (const VkPhysicalDevicePipelineProtectedAccessFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES; - out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; + VkPhysicalDevicePrivateDataFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES); + const VkPhysicalDevicePrivateDataFeatures *in_ext = (const VkPhysicalDevicePrivateDataFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES; + out_ext->privateData = in_ext->privateData; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: { - VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR); - const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; - out_ext->videoMaintenance1 = in_ext->videoMaintenance1; + VkPhysicalDeviceProtectedMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES); + const VkPhysicalDeviceProtectedMemoryFeatures *in_ext = (const VkPhysicalDeviceProtectedMemoryFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES; + out_ext->protectedMemory = in_ext->protectedMemory; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: { - VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR); - const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; - out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9; + VkPhysicalDeviceProvokingVertexFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT); + const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; + out_ext->provokingVertexLast = in_ext->provokingVertexLast; + out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: { - VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR); - const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; - out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap; + VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT); + const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; + out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: { - VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR); - const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; - out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1; + VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT); + const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; + out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess; + out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess; + out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: { - VkPhysicalDeviceInheritedViewportScissorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV); - const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *in_ext = (const VkPhysicalDeviceInheritedViewportScissorFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV; - out_ext->inheritedViewportScissor2D = in_ext->inheritedViewportScissor2D; + VkPhysicalDeviceRawAccessChainsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV); + const VkPhysicalDeviceRawAccessChainsFeaturesNV *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; + out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: { - VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT); - const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; - out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats; + VkPhysicalDeviceRayQueryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR); + const VkPhysicalDeviceRayQueryFeaturesKHR *in_ext = (const VkPhysicalDeviceRayQueryFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR; + out_ext->rayQuery = in_ext->rayQuery; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: { - VkPhysicalDeviceProvokingVertexFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT); - const VkPhysicalDeviceProvokingVertexFeaturesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT; - out_ext->provokingVertexLast = in_ext->provokingVertexLast; - out_ext->transformFeedbackPreservesProvokingVertex = in_ext->transformFeedbackPreservesProvokingVertex; + VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV); + const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; + out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: { - VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR); - const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; - out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh; + VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV); + const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV; + out_ext->spheres = in_ext->spheres; + out_ext->linearSweptSpheres = in_ext->linearSweptSpheres; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceDescriptorBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT); - const VkPhysicalDeviceDescriptorBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT; - out_ext->descriptorBuffer = in_ext->descriptorBuffer; - out_ext->descriptorBufferCaptureReplay = in_ext->descriptorBufferCaptureReplay; - out_ext->descriptorBufferImageLayoutIgnored = in_ext->descriptorBufferImageLayoutIgnored; - out_ext->descriptorBufferPushDescriptors = in_ext->descriptorBufferPushDescriptors; + VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR); + const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR; + out_ext->rayTracingMaintenance1 = in_ext->rayTracingMaintenance1; + out_ext->rayTracingPipelineTraceRaysIndirect2 = in_ext->rayTracingPipelineTraceRaysIndirect2; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: { - VkPhysicalDeviceShaderIntegerDotProductFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES); - const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; - out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; + VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV); + const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; + out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur; + out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: { - VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR); - const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR; - out_ext->fragmentShaderBarycentric = in_ext->fragmentShaderBarycentric; + VkPhysicalDeviceRayTracingPipelineFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR); + const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelineFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR; + out_ext->rayTracingPipeline = in_ext->rayTracingPipeline; + out_ext->rayTracingPipelineShaderGroupHandleCaptureReplay = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplay; + out_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed = in_ext->rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + out_ext->rayTracingPipelineTraceRaysIndirect = in_ext->rayTracingPipelineTraceRaysIndirect; + out_ext->rayTraversalPrimitiveCulling = in_ext->rayTraversalPrimitiveCulling; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: { - VkPhysicalDeviceRayTracingMotionBlurFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV); - const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV; - out_ext->rayTracingMotionBlur = in_ext->rayTracingMotionBlur; - out_ext->rayTracingMotionBlurPipelineTraceRaysIndirect = in_ext->rayTracingMotionBlurPipelineTraceRaysIndirect; + VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR); + const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; + out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch; out_header = (void *)out_ext; break; } @@ -32920,154 +32854,184 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: { - VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV); - const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV; - out_ext->spheres = in_ext->spheres; - out_ext->linearSweptSpheres = in_ext->linearSweptSpheres; + VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG); + const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; + out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: { - VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT); - const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT; - out_ext->formatRgba10x6WithoutYCbCrSampler = in_ext->formatRgba10x6WithoutYCbCrSampler; + VkPhysicalDeviceRenderPassStripedFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM); + const VkPhysicalDeviceRenderPassStripedFeaturesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; + out_ext->renderPassStriped = in_ext->renderPassStriped; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: { - VkPhysicalDeviceDynamicRenderingFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES); - const VkPhysicalDeviceDynamicRenderingFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES; - out_ext->dynamicRendering = in_ext->dynamicRendering; + VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV); + const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *in_ext = (const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV; + out_ext->representativeFragmentTest = in_ext->representativeFragmentTest; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: { - VkPhysicalDeviceImageViewMinLodFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT); - const VkPhysicalDeviceImageViewMinLodFeaturesEXT *in_ext = (const VkPhysicalDeviceImageViewMinLodFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT; - out_ext->minLod = in_ext->minLod; + VkPhysicalDeviceRobustness2FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR); + const VkPhysicalDeviceRobustness2FeaturesKHR *in_ext = (const VkPhysicalDeviceRobustness2FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR; + out_ext->robustBufferAccess2 = in_ext->robustBufferAccess2; + out_ext->robustImageAccess2 = in_ext->robustImageAccess2; + out_ext->nullDescriptor = in_ext->nullDescriptor; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: { - VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT); - const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *in_ext = (const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT; - out_ext->rasterizationOrderColorAttachmentAccess = in_ext->rasterizationOrderColorAttachmentAccess; - out_ext->rasterizationOrderDepthAttachmentAccess = in_ext->rasterizationOrderDepthAttachmentAccess; - out_ext->rasterizationOrderStencilAttachmentAccess = in_ext->rasterizationOrderStencilAttachmentAccess; + VkPhysicalDeviceSamplerYcbcrConversionFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES); + const VkPhysicalDeviceSamplerYcbcrConversionFeatures *in_ext = (const VkPhysicalDeviceSamplerYcbcrConversionFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES; + out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: { - VkPhysicalDeviceLinearColorAttachmentFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV); - const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *in_ext = (const VkPhysicalDeviceLinearColorAttachmentFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV; - out_ext->linearColorAttachment = in_ext->linearColorAttachment; - out_header = (void *)out_ext; + VkPhysicalDeviceScalarBlockLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES); + const VkPhysicalDeviceScalarBlockLayoutFeatures *in_ext = (const VkPhysicalDeviceScalarBlockLayoutFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES; + out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; + out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: { - VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT); - const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT; - out_ext->graphicsPipelineLibrary = in_ext->graphicsPipelineLibrary; + VkPhysicalDeviceSchedulingControlsFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM); + const VkPhysicalDeviceSchedulingControlsFeaturesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; + out_ext->schedulingControls = in_ext->schedulingControls; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: { - VkPhysicalDevicePipelineBinaryFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR); - const VkPhysicalDevicePipelineBinaryFeaturesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR; - out_ext->pipelineBinaries = in_ext->pipelineBinaries; + VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES); + const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *in_ext = (const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES; + out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: { - VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE); - const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *in_ext = (const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE; - out_ext->descriptorSetHostMapping = in_ext->descriptorSetHostMapping; + VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV); + const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; + out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: { - VkPhysicalDeviceNestedCommandBufferFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT); - const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *in_ext = (const VkPhysicalDeviceNestedCommandBufferFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT; - out_ext->nestedCommandBuffer = in_ext->nestedCommandBuffer; - out_ext->nestedCommandBufferRendering = in_ext->nestedCommandBufferRendering; - out_ext->nestedCommandBufferSimultaneousUse = in_ext->nestedCommandBufferSimultaneousUse; + VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT); + const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT; + out_ext->shaderBufferFloat16Atomics = in_ext->shaderBufferFloat16Atomics; + out_ext->shaderBufferFloat16AtomicAdd = in_ext->shaderBufferFloat16AtomicAdd; + out_ext->shaderBufferFloat16AtomicMinMax = in_ext->shaderBufferFloat16AtomicMinMax; + out_ext->shaderBufferFloat32AtomicMinMax = in_ext->shaderBufferFloat32AtomicMinMax; + out_ext->shaderBufferFloat64AtomicMinMax = in_ext->shaderBufferFloat64AtomicMinMax; + out_ext->shaderSharedFloat16Atomics = in_ext->shaderSharedFloat16Atomics; + out_ext->shaderSharedFloat16AtomicAdd = in_ext->shaderSharedFloat16AtomicAdd; + out_ext->shaderSharedFloat16AtomicMinMax = in_ext->shaderSharedFloat16AtomicMinMax; + out_ext->shaderSharedFloat32AtomicMinMax = in_ext->shaderSharedFloat32AtomicMinMax; + out_ext->shaderSharedFloat64AtomicMinMax = in_ext->shaderSharedFloat64AtomicMinMax; + out_ext->shaderImageFloat32AtomicMinMax = in_ext->shaderImageFloat32AtomicMinMax; + out_ext->sparseImageFloat32AtomicMinMax = in_ext->sparseImageFloat32AtomicMinMax; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: { - VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT); - const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; - out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier; + VkPhysicalDeviceShaderAtomicFloatFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT); + const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT; + out_ext->shaderBufferFloat32Atomics = in_ext->shaderBufferFloat32Atomics; + out_ext->shaderBufferFloat32AtomicAdd = in_ext->shaderBufferFloat32AtomicAdd; + out_ext->shaderBufferFloat64Atomics = in_ext->shaderBufferFloat64Atomics; + out_ext->shaderBufferFloat64AtomicAdd = in_ext->shaderBufferFloat64AtomicAdd; + out_ext->shaderSharedFloat32Atomics = in_ext->shaderSharedFloat32Atomics; + out_ext->shaderSharedFloat32AtomicAdd = in_ext->shaderSharedFloat32AtomicAdd; + out_ext->shaderSharedFloat64Atomics = in_ext->shaderSharedFloat64Atomics; + out_ext->shaderSharedFloat64AtomicAdd = in_ext->shaderSharedFloat64AtomicAdd; + out_ext->shaderImageFloat32Atomics = in_ext->shaderImageFloat32Atomics; + out_ext->shaderImageFloat32AtomicAdd = in_ext->shaderImageFloat32AtomicAdd; + out_ext->sparseImageFloat32Atomics = in_ext->sparseImageFloat32Atomics; + out_ext->sparseImageFloat32AtomicAdd = in_ext->sparseImageFloat32AtomicAdd; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: { - VkPhysicalDeviceImageCompressionControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT); - const VkPhysicalDeviceImageCompressionControlFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT; - out_ext->imageCompressionControl = in_ext->imageCompressionControl; + VkPhysicalDeviceShaderAtomicInt64Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES); + const VkPhysicalDeviceShaderAtomicInt64Features *in_ext = (const VkPhysicalDeviceShaderAtomicInt64Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES; + out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; + out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: { - VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT); - const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *in_ext = (const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT; - out_ext->imageCompressionControlSwapchain = in_ext->imageCompressionControlSwapchain; + VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR); + const VkPhysicalDeviceShaderBfloat16FeaturesKHR *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; + out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type; + out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct; + out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: { - VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT); - const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; - out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback; + VkPhysicalDeviceShaderClockFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR); + const VkPhysicalDeviceShaderClockFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderClockFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR; + out_ext->shaderSubgroupClock = in_ext->shaderSubgroupClock; + out_ext->shaderDeviceClock = in_ext->shaderDeviceClock; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: { - VkPhysicalDeviceOpacityMicromapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT); - const VkPhysicalDeviceOpacityMicromapFeaturesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT; - out_ext->micromap = in_ext->micromap; - out_ext->micromapCaptureReplay = in_ext->micromapCaptureReplay; - out_ext->micromapHostCommands = in_ext->micromapHostCommands; + VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM); + const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; + out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: { - VkPhysicalDevicePipelinePropertiesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT); - const VkPhysicalDevicePipelinePropertiesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelinePropertiesFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT; - out_ext->pipelinePropertiesIdentifier = in_ext->pipelinePropertiesIdentifier; + VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES); + const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES; + out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + { + VkPhysicalDeviceShaderDrawParametersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES); + const VkPhysicalDeviceShaderDrawParametersFeatures *in_ext = (const VkPhysicalDeviceShaderDrawParametersFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES; + out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; out_header = (void *)out_ext; break; } @@ -33080,189 +33044,178 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: { - VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT); - const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *in_ext = (const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT; - out_ext->nonSeamlessCubeMap = in_ext->nonSeamlessCubeMap; + VkPhysicalDeviceShaderExpectAssumeFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES); + const VkPhysicalDeviceShaderExpectAssumeFeatures *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; + out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: { - VkPhysicalDevicePipelineRobustnessFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES); - const VkPhysicalDevicePipelineRobustnessFeatures *in_ext = (const VkPhysicalDevicePipelineRobustnessFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES; - out_ext->pipelineRobustness = in_ext->pipelineRobustness; + VkPhysicalDeviceShaderFloat16Int8Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES); + const VkPhysicalDeviceShaderFloat16Int8Features *in_ext = (const VkPhysicalDeviceShaderFloat16Int8Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES; + out_ext->shaderFloat16 = in_ext->shaderFloat16; + out_ext->shaderInt8 = in_ext->shaderInt8; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: { - VkPhysicalDeviceImageProcessingFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM); - const VkPhysicalDeviceImageProcessingFeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM; - out_ext->textureSampleWeighted = in_ext->textureSampleWeighted; - out_ext->textureBoxFilter = in_ext->textureBoxFilter; - out_ext->textureBlockMatch = in_ext->textureBlockMatch; + VkPhysicalDeviceShaderFloat8FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT); + const VkPhysicalDeviceShaderFloat8FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; + out_ext->shaderFloat8 = in_ext->shaderFloat8; + out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: { - VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM); - const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; - out_ext->tileProperties = in_ext->tileProperties; + VkPhysicalDeviceShaderFloatControls2Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES); + const VkPhysicalDeviceShaderFloatControls2Features *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; + out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: { - VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT); - const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *in_ext = (const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT; - out_ext->attachmentFeedbackLoopLayout = in_ext->attachmentFeedbackLoopLayout; + VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT); + const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT; + out_ext->shaderImageInt64Atomics = in_ext->shaderImageInt64Atomics; + out_ext->sparseImageInt64Atomics = in_ext->sparseImageInt64Atomics; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: { - VkPhysicalDeviceAddressBindingReportFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT); - const VkPhysicalDeviceAddressBindingReportFeaturesEXT *in_ext = (const VkPhysicalDeviceAddressBindingReportFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT; - out_ext->reportAddressBinding = in_ext->reportAddressBinding; + VkPhysicalDeviceShaderImageFootprintFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV); + const VkPhysicalDeviceShaderImageFootprintFeaturesNV *in_ext = (const VkPhysicalDeviceShaderImageFootprintFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV; + out_ext->imageFootprint = in_ext->imageFootprint; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: { - VkPhysicalDeviceOpticalFlowFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV); - const VkPhysicalDeviceOpticalFlowFeaturesNV *in_ext = (const VkPhysicalDeviceOpticalFlowFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV; - out_ext->opticalFlow = in_ext->opticalFlow; + VkPhysicalDeviceShaderIntegerDotProductFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES); + const VkPhysicalDeviceShaderIntegerDotProductFeatures *in_ext = (const VkPhysicalDeviceShaderIntegerDotProductFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES; + out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: { - VkPhysicalDeviceFaultFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT); - const VkPhysicalDeviceFaultFeaturesEXT *in_ext = (const VkPhysicalDeviceFaultFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT; - out_ext->deviceFault = in_ext->deviceFault; - out_ext->deviceFaultVendorBinary = in_ext->deviceFaultVendorBinary; + VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL); + const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *in_ext = (const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL; + out_ext->shaderIntegerFunctions2 = in_ext->shaderIntegerFunctions2; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: { - VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT); - const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *in_ext = (const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT; - out_ext->pipelineLibraryGroupHandles = in_ext->pipelineLibraryGroupHandles; + VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR); + const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; + out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: { - VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM); - const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM; - out_ext->shaderCoreBuiltins = in_ext->shaderCoreBuiltins; + VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT); + const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT; + out_ext->shaderModuleIdentifier = in_ext->shaderModuleIdentifier; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: { - VkPhysicalDeviceFrameBoundaryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT); - const VkPhysicalDeviceFrameBoundaryFeaturesEXT *in_ext = (const VkPhysicalDeviceFrameBoundaryFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT; - out_ext->frameBoundary = in_ext->frameBoundary; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: - { - VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT); - const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *in_ext = (const VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT; - out_ext->dynamicRenderingUnusedAttachments = in_ext->dynamicRenderingUnusedAttachments; + VkPhysicalDeviceShaderObjectFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT); + const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; + out_ext->shaderObject = in_ext->shaderObject; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: { - VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR); - const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; - out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1; + VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR); + const VkPhysicalDeviceShaderQuadControlFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; + out_ext->shaderQuadControl = in_ext->shaderQuadControl; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: { - VkPhysicalDeviceDepthBiasControlFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT); - const VkPhysicalDeviceDepthBiasControlFeaturesEXT *in_ext = (const VkPhysicalDeviceDepthBiasControlFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT; - out_ext->depthBiasControl = in_ext->depthBiasControl; - out_ext->leastRepresentableValueForceUnormRepresentation = in_ext->leastRepresentableValueForceUnormRepresentation; - out_ext->floatRepresentation = in_ext->floatRepresentation; - out_ext->depthBiasExact = in_ext->depthBiasExact; + VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR); + const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR; + out_ext->shaderRelaxedExtendedInstruction = in_ext->shaderRelaxedExtendedInstruction; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: { - VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV); - const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV; - out_ext->rayTracingInvocationReorder = in_ext->rayTracingInvocationReorder; + VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT); + const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; + out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: { - VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV); - const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV; - out_ext->extendedSparseAddressSpace = in_ext->extendedSparseAddressSpace; + VkPhysicalDeviceShaderSMBuiltinsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV); + const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV; + out_ext->shaderSMBuiltins = in_ext->shaderSMBuiltins; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: { - VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM); - const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM; - out_ext->multiviewPerViewViewports = in_ext->multiviewPerViewViewports; + VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES); + const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES; + out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: { - VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR); - const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *in_ext = (const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR; - out_ext->rayTracingPositionFetch = in_ext->rayTracingPositionFetch; + VkPhysicalDeviceShaderSubgroupRotateFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES); + const VkPhysicalDeviceShaderSubgroupRotateFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; + out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; + out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: { - VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM); - const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *in_ext = (const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM; - out_ext->multiviewPerViewRenderAreas = in_ext->multiviewPerViewRenderAreas; + VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR); + const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR; + out_ext->shaderSubgroupUniformControlFlow = in_ext->shaderSubgroupUniformControlFlow; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: { - VkPhysicalDeviceShaderObjectFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT); - const VkPhysicalDeviceShaderObjectFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderObjectFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT; - out_ext->shaderObject = in_ext->shaderObject; + VkPhysicalDeviceShaderTerminateInvocationFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES); + const VkPhysicalDeviceShaderTerminateInvocationFeatures *in_ext = (const VkPhysicalDeviceShaderTerminateInvocationFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES; + out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; out_header = (void *)out_ext; break; } @@ -33277,409 +33230,456 @@ static void convert_VkPhysicalDeviceFeatures2_host_to_win32(const VkPhysicalDevi out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: { - VkPhysicalDeviceCooperativeMatrixFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR); - const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR; - out_ext->cooperativeMatrix = in_ext->cooperativeMatrix; - out_ext->cooperativeMatrixRobustBufferAccess = in_ext->cooperativeMatrixRobustBufferAccess; + VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR); + const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; + out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: { - VkPhysicalDeviceAntiLagFeaturesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD); - const VkPhysicalDeviceAntiLagFeaturesAMD *in_ext = (const VkPhysicalDeviceAntiLagFeaturesAMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD; - out_ext->antiLag = in_ext->antiLag; + VkPhysicalDeviceShadingRateImageFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV); + const VkPhysicalDeviceShadingRateImageFeaturesNV *in_ext = (const VkPhysicalDeviceShadingRateImageFeaturesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV; + out_ext->shadingRateImage = in_ext->shadingRateImage; + out_ext->shadingRateCoarseSampleOrder = in_ext->shadingRateCoarseSampleOrder; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: { - VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM); - const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; - out_ext->tileMemoryHeap = in_ext->tileMemoryHeap; + VkPhysicalDeviceSubgroupSizeControlFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES); + const VkPhysicalDeviceSubgroupSizeControlFeatures *in_ext = (const VkPhysicalDeviceSubgroupSizeControlFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES; + out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; + out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: { - VkPhysicalDeviceCubicClampFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM); - const VkPhysicalDeviceCubicClampFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicClampFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM; - out_ext->cubicRangeClamp = in_ext->cubicRangeClamp; + VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT); + const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT; + out_ext->subpassMergeFeedback = in_ext->subpassMergeFeedback; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: { - VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM); - const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; - out_ext->ycbcrDegamma = in_ext->ycbcrDegamma; + VkPhysicalDeviceSubpassShadingFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI); + const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI; + out_ext->subpassShading = in_ext->subpassShading; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDeviceCubicWeightsFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM); - const VkPhysicalDeviceCubicWeightsFeaturesQCOM *in_ext = (const VkPhysicalDeviceCubicWeightsFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM; - out_ext->selectableCubicWeights = in_ext->selectableCubicWeights; + VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR); + const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR; + out_ext->swapchainMaintenance1 = in_ext->swapchainMaintenance1; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: { - VkPhysicalDeviceImageProcessing2FeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM); - const VkPhysicalDeviceImageProcessing2FeaturesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing2FeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM; - out_ext->textureBlockMatch2 = in_ext->textureBlockMatch2; + VkPhysicalDeviceSynchronization2Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES); + const VkPhysicalDeviceSynchronization2Features *in_ext = (const VkPhysicalDeviceSynchronization2Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES; + out_ext->synchronization2 = in_ext->synchronization2; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: { - VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV); - const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *in_ext = (const VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV; - out_ext->descriptorPoolOverallocation = in_ext->descriptorPoolOverallocation; + VkPhysicalDeviceTensorFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM); + const VkPhysicalDeviceTensorFeaturesARM *in_ext = (const VkPhysicalDeviceTensorFeaturesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; + out_ext->tensorNonPacked = in_ext->tensorNonPacked; + out_ext->shaderTensorAccess = in_ext->shaderTensorAccess; + out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing; + out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing; + out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind; + out_ext->tensors = in_ext->tensors; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: { - VkPhysicalDevicePerStageDescriptorSetFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV); - const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *in_ext = (const VkPhysicalDevicePerStageDescriptorSetFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV; - out_ext->perStageDescriptorSet = in_ext->perStageDescriptorSet; - out_ext->dynamicPipelineLayout = in_ext->dynamicPipelineLayout; + VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT); + const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT; + out_ext->texelBufferAlignment = in_ext->texelBufferAlignment; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: { - VkPhysicalDeviceSchedulingControlsFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM); - const VkPhysicalDeviceSchedulingControlsFeaturesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM; - out_ext->schedulingControls = in_ext->schedulingControls; + VkPhysicalDeviceTextureCompressionASTCHDRFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES); + const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *in_ext = (const VkPhysicalDeviceTextureCompressionASTCHDRFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES; + out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: { - VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG); - const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *in_ext = (const VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG; - out_ext->relaxedLineRasterization = in_ext->relaxedLineRasterization; + VkPhysicalDeviceTileMemoryHeapFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM); + const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileMemoryHeapFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM; + out_ext->tileMemoryHeap = in_ext->tileMemoryHeap; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: { - VkPhysicalDeviceRenderPassStripedFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM); - const VkPhysicalDeviceRenderPassStripedFeaturesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM; - out_ext->renderPassStriped = in_ext->renderPassStriped; + VkPhysicalDeviceTilePropertiesFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM); + const VkPhysicalDeviceTilePropertiesFeaturesQCOM *in_ext = (const VkPhysicalDeviceTilePropertiesFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM; + out_ext->tileProperties = in_ext->tileProperties; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: { - VkPhysicalDevicePipelineOpacityMicromapFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM); - const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *in_ext = (const VkPhysicalDevicePipelineOpacityMicromapFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM; - out_ext->pipelineOpacityMicromap = in_ext->pipelineOpacityMicromap; + VkPhysicalDeviceTileShadingFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM); + const VkPhysicalDeviceTileShadingFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; + out_ext->tileShading = in_ext->tileShading; + out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage; + out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments; + out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments; + out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments; + out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments; + out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments; + out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw; + out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch; + out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile; + out_ext->tileShadingApron = in_ext->tileShadingApron; + out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron; + out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps; + out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: { - VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR); - const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR; - out_ext->shaderMaximalReconvergence = in_ext->shaderMaximalReconvergence; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: - { - VkPhysicalDeviceShaderSubgroupRotateFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES); - const VkPhysicalDeviceShaderSubgroupRotateFeatures *in_ext = (const VkPhysicalDeviceShaderSubgroupRotateFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES; - out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; - out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; + VkPhysicalDeviceTimelineSemaphoreFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES); + const VkPhysicalDeviceTimelineSemaphoreFeatures *in_ext = (const VkPhysicalDeviceTimelineSemaphoreFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES; + out_ext->timelineSemaphore = in_ext->timelineSemaphore; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: { - VkPhysicalDeviceShaderExpectAssumeFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES); - const VkPhysicalDeviceShaderExpectAssumeFeatures *in_ext = (const VkPhysicalDeviceShaderExpectAssumeFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES; - out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; + VkPhysicalDeviceTransformFeedbackFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT); + const VkPhysicalDeviceTransformFeedbackFeaturesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; + out_ext->transformFeedback = in_ext->transformFeedback; + out_ext->geometryStreams = in_ext->geometryStreams; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: { - VkPhysicalDeviceShaderFloatControls2Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES); - const VkPhysicalDeviceShaderFloatControls2Features *in_ext = (const VkPhysicalDeviceShaderFloatControls2Features *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES; - out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; + VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR); + const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *in_ext = (const VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR; + out_ext->unifiedImageLayouts = in_ext->unifiedImageLayouts; + out_ext->unifiedImageLayoutsVideo = in_ext->unifiedImageLayoutsVideo; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: { - VkPhysicalDeviceDynamicRenderingLocalReadFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES); - const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *in_ext = (const VkPhysicalDeviceDynamicRenderingLocalReadFeatures *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES; - out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; + VkPhysicalDeviceUniformBufferStandardLayoutFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES); + const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *in_ext = (const VkPhysicalDeviceUniformBufferStandardLayoutFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES; + out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: { - VkPhysicalDeviceShaderQuadControlFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR); - const VkPhysicalDeviceShaderQuadControlFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderQuadControlFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR; - out_ext->shaderQuadControl = in_ext->shaderQuadControl; + VkPhysicalDeviceVariablePointersFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES); + const VkPhysicalDeviceVariablePointersFeatures *in_ext = (const VkPhysicalDeviceVariablePointersFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES; + out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; + out_ext->variablePointers = in_ext->variablePointers; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: { - VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV); - const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *in_ext = (const VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV; - out_ext->shaderFloat16VectorAtomics = in_ext->shaderFloat16VectorAtomics; + VkPhysicalDeviceVertexAttributeDivisorFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES); + const VkPhysicalDeviceVertexAttributeDivisorFeatures *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES; + out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; + out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: { - VkPhysicalDeviceMapMemoryPlacedFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT); - const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT; - out_ext->memoryMapPlaced = in_ext->memoryMapPlaced; - out_ext->memoryMapRangePlaced = in_ext->memoryMapRangePlaced; - out_ext->memoryUnmapReserve = in_ext->memoryUnmapReserve; + VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT); + const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; + out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: { - VkPhysicalDeviceShaderBfloat16FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR); - const VkPhysicalDeviceShaderBfloat16FeaturesKHR *in_ext = (const VkPhysicalDeviceShaderBfloat16FeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR; - out_ext->shaderBFloat16Type = in_ext->shaderBFloat16Type; - out_ext->shaderBFloat16DotProduct = in_ext->shaderBFloat16DotProduct; - out_ext->shaderBFloat16CooperativeMatrix = in_ext->shaderBFloat16CooperativeMatrix; + VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT); + const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT; + out_ext->vertexInputDynamicState = in_ext->vertexInputDynamicState; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: { - VkPhysicalDeviceRawAccessChainsFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV); - const VkPhysicalDeviceRawAccessChainsFeaturesNV *in_ext = (const VkPhysicalDeviceRawAccessChainsFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV; - out_ext->shaderRawAccessChains = in_ext->shaderRawAccessChains; + VkPhysicalDeviceVideoDecodeVP9FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR); + const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoDecodeVP9FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR; + out_ext->videoDecodeVP9 = in_ext->videoDecodeVP9; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: { - VkPhysicalDeviceCommandBufferInheritanceFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV); - const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *in_ext = (const VkPhysicalDeviceCommandBufferInheritanceFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV; - out_ext->commandBufferInheritance = in_ext->commandBufferInheritance; + VkPhysicalDeviceVideoEncodeAV1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR); + const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeAV1FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR; + out_ext->videoEncodeAV1 = in_ext->videoEncodeAV1; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: { - VkPhysicalDeviceImageAlignmentControlFeaturesMESA32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA); - const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *in_ext = (const VkPhysicalDeviceImageAlignmentControlFeaturesMESA *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA; - out_ext->imageAlignmentControl = in_ext->imageAlignmentControl; + VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR); + const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR; + out_ext->videoEncodeIntraRefresh = in_ext->videoEncodeIntraRefresh; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: { - VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT); - const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *in_ext = (const VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT; - out_ext->shaderReplicatedComposites = in_ext->shaderReplicatedComposites; + VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR); + const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *in_ext = (const VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR; + out_ext->videoEncodeQuantizationMap = in_ext->videoEncodeQuantizationMap; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: { - VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR); - const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *in_ext = (const VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR; - out_ext->presentModeFifoLatestReady = in_ext->presentModeFifoLatestReady; + VkPhysicalDeviceVideoMaintenance1FeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR); + const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *in_ext = (const VkPhysicalDeviceVideoMaintenance1FeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR; + out_ext->videoMaintenance1 = in_ext->videoMaintenance1; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: { - VkPhysicalDeviceCooperativeMatrix2FeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV); - const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2FeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV; - out_ext->cooperativeMatrixWorkgroupScope = in_ext->cooperativeMatrixWorkgroupScope; - out_ext->cooperativeMatrixFlexibleDimensions = in_ext->cooperativeMatrixFlexibleDimensions; - out_ext->cooperativeMatrixReductions = in_ext->cooperativeMatrixReductions; - out_ext->cooperativeMatrixConversions = in_ext->cooperativeMatrixConversions; - out_ext->cooperativeMatrixPerElementOperations = in_ext->cooperativeMatrixPerElementOperations; - out_ext->cooperativeMatrixTensorAddressing = in_ext->cooperativeMatrixTensorAddressing; - out_ext->cooperativeMatrixBlockLoads = in_ext->cooperativeMatrixBlockLoads; + VkPhysicalDeviceVulkan11Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES); + const VkPhysicalDeviceVulkan11Features *in_ext = (const VkPhysicalDeviceVulkan11Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; + out_ext->storageBuffer16BitAccess = in_ext->storageBuffer16BitAccess; + out_ext->uniformAndStorageBuffer16BitAccess = in_ext->uniformAndStorageBuffer16BitAccess; + out_ext->storagePushConstant16 = in_ext->storagePushConstant16; + out_ext->storageInputOutput16 = in_ext->storageInputOutput16; + out_ext->multiview = in_ext->multiview; + out_ext->multiviewGeometryShader = in_ext->multiviewGeometryShader; + out_ext->multiviewTessellationShader = in_ext->multiviewTessellationShader; + out_ext->variablePointersStorageBuffer = in_ext->variablePointersStorageBuffer; + out_ext->variablePointers = in_ext->variablePointers; + out_ext->protectedMemory = in_ext->protectedMemory; + out_ext->samplerYcbcrConversion = in_ext->samplerYcbcrConversion; + out_ext->shaderDrawParameters = in_ext->shaderDrawParameters; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: { - VkPhysicalDeviceHdrVividFeaturesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI); - const VkPhysicalDeviceHdrVividFeaturesHUAWEI *in_ext = (const VkPhysicalDeviceHdrVividFeaturesHUAWEI *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI; - out_ext->hdrVivid = in_ext->hdrVivid; + VkPhysicalDeviceVulkan12Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES); + const VkPhysicalDeviceVulkan12Features *in_ext = (const VkPhysicalDeviceVulkan12Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; + out_ext->samplerMirrorClampToEdge = in_ext->samplerMirrorClampToEdge; + out_ext->drawIndirectCount = in_ext->drawIndirectCount; + out_ext->storageBuffer8BitAccess = in_ext->storageBuffer8BitAccess; + out_ext->uniformAndStorageBuffer8BitAccess = in_ext->uniformAndStorageBuffer8BitAccess; + out_ext->storagePushConstant8 = in_ext->storagePushConstant8; + out_ext->shaderBufferInt64Atomics = in_ext->shaderBufferInt64Atomics; + out_ext->shaderSharedInt64Atomics = in_ext->shaderSharedInt64Atomics; + out_ext->shaderFloat16 = in_ext->shaderFloat16; + out_ext->shaderInt8 = in_ext->shaderInt8; + out_ext->descriptorIndexing = in_ext->descriptorIndexing; + out_ext->shaderInputAttachmentArrayDynamicIndexing = in_ext->shaderInputAttachmentArrayDynamicIndexing; + out_ext->shaderUniformTexelBufferArrayDynamicIndexing = in_ext->shaderUniformTexelBufferArrayDynamicIndexing; + out_ext->shaderStorageTexelBufferArrayDynamicIndexing = in_ext->shaderStorageTexelBufferArrayDynamicIndexing; + out_ext->shaderUniformBufferArrayNonUniformIndexing = in_ext->shaderUniformBufferArrayNonUniformIndexing; + out_ext->shaderSampledImageArrayNonUniformIndexing = in_ext->shaderSampledImageArrayNonUniformIndexing; + out_ext->shaderStorageBufferArrayNonUniformIndexing = in_ext->shaderStorageBufferArrayNonUniformIndexing; + out_ext->shaderStorageImageArrayNonUniformIndexing = in_ext->shaderStorageImageArrayNonUniformIndexing; + out_ext->shaderInputAttachmentArrayNonUniformIndexing = in_ext->shaderInputAttachmentArrayNonUniformIndexing; + out_ext->shaderUniformTexelBufferArrayNonUniformIndexing = in_ext->shaderUniformTexelBufferArrayNonUniformIndexing; + out_ext->shaderStorageTexelBufferArrayNonUniformIndexing = in_ext->shaderStorageTexelBufferArrayNonUniformIndexing; + out_ext->descriptorBindingUniformBufferUpdateAfterBind = in_ext->descriptorBindingUniformBufferUpdateAfterBind; + out_ext->descriptorBindingSampledImageUpdateAfterBind = in_ext->descriptorBindingSampledImageUpdateAfterBind; + out_ext->descriptorBindingStorageImageUpdateAfterBind = in_ext->descriptorBindingStorageImageUpdateAfterBind; + out_ext->descriptorBindingStorageBufferUpdateAfterBind = in_ext->descriptorBindingStorageBufferUpdateAfterBind; + out_ext->descriptorBindingUniformTexelBufferUpdateAfterBind = in_ext->descriptorBindingUniformTexelBufferUpdateAfterBind; + out_ext->descriptorBindingStorageTexelBufferUpdateAfterBind = in_ext->descriptorBindingStorageTexelBufferUpdateAfterBind; + out_ext->descriptorBindingUpdateUnusedWhilePending = in_ext->descriptorBindingUpdateUnusedWhilePending; + out_ext->descriptorBindingPartiallyBound = in_ext->descriptorBindingPartiallyBound; + out_ext->descriptorBindingVariableDescriptorCount = in_ext->descriptorBindingVariableDescriptorCount; + out_ext->runtimeDescriptorArray = in_ext->runtimeDescriptorArray; + out_ext->samplerFilterMinmax = in_ext->samplerFilterMinmax; + out_ext->scalarBlockLayout = in_ext->scalarBlockLayout; + out_ext->imagelessFramebuffer = in_ext->imagelessFramebuffer; + out_ext->uniformBufferStandardLayout = in_ext->uniformBufferStandardLayout; + out_ext->shaderSubgroupExtendedTypes = in_ext->shaderSubgroupExtendedTypes; + out_ext->separateDepthStencilLayouts = in_ext->separateDepthStencilLayouts; + out_ext->hostQueryReset = in_ext->hostQueryReset; + out_ext->timelineSemaphore = in_ext->timelineSemaphore; + out_ext->bufferDeviceAddress = in_ext->bufferDeviceAddress; + out_ext->bufferDeviceAddressCaptureReplay = in_ext->bufferDeviceAddressCaptureReplay; + out_ext->bufferDeviceAddressMultiDevice = in_ext->bufferDeviceAddressMultiDevice; + out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; + out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; + out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; + out_ext->shaderOutputViewportIndex = in_ext->shaderOutputViewportIndex; + out_ext->shaderOutputLayer = in_ext->shaderOutputLayer; + out_ext->subgroupBroadcastDynamicId = in_ext->subgroupBroadcastDynamicId; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: { - VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT); - const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT; - out_ext->vertexAttributeRobustness = in_ext->vertexAttributeRobustness; + VkPhysicalDeviceVulkan13Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES); + const VkPhysicalDeviceVulkan13Features *in_ext = (const VkPhysicalDeviceVulkan13Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; + out_ext->robustImageAccess = in_ext->robustImageAccess; + out_ext->inlineUniformBlock = in_ext->inlineUniformBlock; + out_ext->descriptorBindingInlineUniformBlockUpdateAfterBind = in_ext->descriptorBindingInlineUniformBlockUpdateAfterBind; + out_ext->pipelineCreationCacheControl = in_ext->pipelineCreationCacheControl; + out_ext->privateData = in_ext->privateData; + out_ext->shaderDemoteToHelperInvocation = in_ext->shaderDemoteToHelperInvocation; + out_ext->shaderTerminateInvocation = in_ext->shaderTerminateInvocation; + out_ext->subgroupSizeControl = in_ext->subgroupSizeControl; + out_ext->computeFullSubgroups = in_ext->computeFullSubgroups; + out_ext->synchronization2 = in_ext->synchronization2; + out_ext->textureCompressionASTC_HDR = in_ext->textureCompressionASTC_HDR; + out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; + out_ext->dynamicRendering = in_ext->dynamicRendering; + out_ext->shaderIntegerDotProduct = in_ext->shaderIntegerDotProduct; + out_ext->maintenance4 = in_ext->maintenance4; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: { - VkPhysicalDeviceDepthClampZeroOneFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR); - const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *in_ext = (const VkPhysicalDeviceDepthClampZeroOneFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR; - out_ext->depthClampZeroOne = in_ext->depthClampZeroOne; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: - { - VkPhysicalDeviceCooperativeVectorFeaturesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV); - const VkPhysicalDeviceCooperativeVectorFeaturesNV *in_ext = (const VkPhysicalDeviceCooperativeVectorFeaturesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV; - out_ext->cooperativeVector = in_ext->cooperativeVector; - out_ext->cooperativeVectorTraining = in_ext->cooperativeVectorTraining; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: - { - VkPhysicalDeviceTileShadingFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM); - const VkPhysicalDeviceTileShadingFeaturesQCOM *in_ext = (const VkPhysicalDeviceTileShadingFeaturesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM; - out_ext->tileShading = in_ext->tileShading; - out_ext->tileShadingFragmentStage = in_ext->tileShadingFragmentStage; - out_ext->tileShadingColorAttachments = in_ext->tileShadingColorAttachments; - out_ext->tileShadingDepthAttachments = in_ext->tileShadingDepthAttachments; - out_ext->tileShadingStencilAttachments = in_ext->tileShadingStencilAttachments; - out_ext->tileShadingInputAttachments = in_ext->tileShadingInputAttachments; - out_ext->tileShadingSampledAttachments = in_ext->tileShadingSampledAttachments; - out_ext->tileShadingPerTileDraw = in_ext->tileShadingPerTileDraw; - out_ext->tileShadingPerTileDispatch = in_ext->tileShadingPerTileDispatch; - out_ext->tileShadingDispatchTile = in_ext->tileShadingDispatchTile; - out_ext->tileShadingApron = in_ext->tileShadingApron; - out_ext->tileShadingAnisotropicApron = in_ext->tileShadingAnisotropicApron; - out_ext->tileShadingAtomicOps = in_ext->tileShadingAtomicOps; - out_ext->tileShadingImageProcessing = in_ext->tileShadingImageProcessing; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: - { - VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE); - const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *in_ext = (const VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE; - out_ext->fragmentDensityMapLayered = in_ext->fragmentDensityMapLayered; + VkPhysicalDeviceVulkan14Features32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES); + const VkPhysicalDeviceVulkan14Features *in_ext = (const VkPhysicalDeviceVulkan14Features *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES; + out_ext->globalPriorityQuery = in_ext->globalPriorityQuery; + out_ext->shaderSubgroupRotate = in_ext->shaderSubgroupRotate; + out_ext->shaderSubgroupRotateClustered = in_ext->shaderSubgroupRotateClustered; + out_ext->shaderFloatControls2 = in_ext->shaderFloatControls2; + out_ext->shaderExpectAssume = in_ext->shaderExpectAssume; + out_ext->rectangularLines = in_ext->rectangularLines; + out_ext->bresenhamLines = in_ext->bresenhamLines; + out_ext->smoothLines = in_ext->smoothLines; + out_ext->stippledRectangularLines = in_ext->stippledRectangularLines; + out_ext->stippledBresenhamLines = in_ext->stippledBresenhamLines; + out_ext->stippledSmoothLines = in_ext->stippledSmoothLines; + out_ext->vertexAttributeInstanceRateDivisor = in_ext->vertexAttributeInstanceRateDivisor; + out_ext->vertexAttributeInstanceRateZeroDivisor = in_ext->vertexAttributeInstanceRateZeroDivisor; + out_ext->indexTypeUint8 = in_ext->indexTypeUint8; + out_ext->dynamicRenderingLocalRead = in_ext->dynamicRenderingLocalRead; + out_ext->maintenance5 = in_ext->maintenance5; + out_ext->maintenance6 = in_ext->maintenance6; + out_ext->pipelineProtectedAccess = in_ext->pipelineProtectedAccess; + out_ext->pipelineRobustness = in_ext->pipelineRobustness; + out_ext->hostImageCopy = in_ext->hostImageCopy; + out_ext->pushDescriptor = in_ext->pushDescriptor; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: { - VkPhysicalDeviceFormatPackFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM); - const VkPhysicalDeviceFormatPackFeaturesARM *in_ext = (const VkPhysicalDeviceFormatPackFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM; - out_ext->formatPack = in_ext->formatPack; + VkPhysicalDeviceVulkanMemoryModelFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES); + const VkPhysicalDeviceVulkanMemoryModelFeatures *in_ext = (const VkPhysicalDeviceVulkanMemoryModelFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES; + out_ext->vulkanMemoryModel = in_ext->vulkanMemoryModel; + out_ext->vulkanMemoryModelDeviceScope = in_ext->vulkanMemoryModelDeviceScope; + out_ext->vulkanMemoryModelAvailabilityVisibilityChains = in_ext->vulkanMemoryModelAvailabilityVisibilityChains; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: { - VkPhysicalDeviceTensorFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM); - const VkPhysicalDeviceTensorFeaturesARM *in_ext = (const VkPhysicalDeviceTensorFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM; - out_ext->tensorNonPacked = in_ext->tensorNonPacked; - out_ext->shaderTensorAccess = in_ext->shaderTensorAccess; - out_ext->shaderStorageTensorArrayDynamicIndexing = in_ext->shaderStorageTensorArrayDynamicIndexing; - out_ext->shaderStorageTensorArrayNonUniformIndexing = in_ext->shaderStorageTensorArrayNonUniformIndexing; - out_ext->descriptorBindingStorageTensorUpdateAfterBind = in_ext->descriptorBindingStorageTensorUpdateAfterBind; - out_ext->tensors = in_ext->tensors; + VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR); + const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *in_ext = (const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR; + out_ext->workgroupMemoryExplicitLayout = in_ext->workgroupMemoryExplicitLayout; + out_ext->workgroupMemoryExplicitLayoutScalarBlockLayout = in_ext->workgroupMemoryExplicitLayoutScalarBlockLayout; + out_ext->workgroupMemoryExplicitLayout8BitAccess = in_ext->workgroupMemoryExplicitLayout8BitAccess; + out_ext->workgroupMemoryExplicitLayout16BitAccess = in_ext->workgroupMemoryExplicitLayout16BitAccess; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: { - VkPhysicalDeviceDescriptorBufferTensorFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM); - const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM; - out_ext->descriptorBufferTensorDescriptors = in_ext->descriptorBufferTensorDescriptors; + VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT); + const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT; + out_ext->ycbcr2plane444Formats = in_ext->ycbcr2plane444Formats; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: { - VkPhysicalDeviceShaderFloat8FeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT); - const VkPhysicalDeviceShaderFloat8FeaturesEXT *in_ext = (const VkPhysicalDeviceShaderFloat8FeaturesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT; - out_ext->shaderFloat8 = in_ext->shaderFloat8; - out_ext->shaderFloat8CooperativeMatrix = in_ext->shaderFloat8CooperativeMatrix; + VkPhysicalDeviceYcbcrDegammaFeaturesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM); + const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *in_ext = (const VkPhysicalDeviceYcbcrDegammaFeaturesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM; + out_ext->ycbcrDegamma = in_ext->ycbcrDegamma; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: { - VkPhysicalDeviceDataGraphFeaturesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM); - const VkPhysicalDeviceDataGraphFeaturesARM *in_ext = (const VkPhysicalDeviceDataGraphFeaturesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM; - out_ext->dataGraph = in_ext->dataGraph; - out_ext->dataGraphUpdateAfterBind = in_ext->dataGraphUpdateAfterBind; - out_ext->dataGraphSpecializationConstants = in_ext->dataGraphSpecializationConstants; - out_ext->dataGraphDescriptorBuffer = in_ext->dataGraphDescriptorBuffer; - out_ext->dataGraphShaderModule = in_ext->dataGraphShaderModule; + VkPhysicalDeviceYcbcrImageArraysFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT); + const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *in_ext = (const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT; + out_ext->ycbcrImageArrays = in_ext->ycbcrImageArrays; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: { - VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC); - const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *in_ext = (const VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC; - out_ext->pipelineCacheIncrementalMode = in_ext->pipelineCacheIncrementalMode; + VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT); + const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *in_ext = (const VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT; + out_ext->zeroInitializeDeviceMemory = in_ext->zeroInitializeDeviceMemory; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: { - VkPhysicalDeviceShaderUntypedPointersFeaturesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR); - const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *in_ext = (const VkPhysicalDeviceShaderUntypedPointersFeaturesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR; - out_ext->shaderUntypedPointers = in_ext->shaderUntypedPointers; + VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES); + const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *in_ext = (const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES; + out_ext->shaderZeroInitializeWorkgroupMemory = in_ext->shaderZeroInitializeWorkgroupMemory; out_header = (void *)out_ext; break; } @@ -33703,19 +33703,19 @@ static void convert_VkFormatProperties2_win32_to_host(struct conversion_context { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: { - VkSubpassResolvePerformanceQueryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT; + VkFormatProperties3 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: { - VkFormatProperties3 *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3; + VkSubpassResolvePerformanceQueryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -33750,15 +33750,6 @@ static void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2 { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: - { - VkSubpassResolvePerformanceQueryEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT); - const VkSubpassResolvePerformanceQueryEXT *in_ext = (const VkSubpassResolvePerformanceQueryEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT; - out_ext->optimal = in_ext->optimal; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: { VkFormatProperties332 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3); @@ -33770,6 +33761,15 @@ static void convert_VkFormatProperties2_host_to_win32(const VkFormatProperties2 out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: + { + VkSubpassResolvePerformanceQueryEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT); + const VkSubpassResolvePerformanceQueryEXT *in_ext = (const VkSubpassResolvePerformanceQueryEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT; + out_ext->optimal = in_ext->optimal; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: { VkTensorFormatPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM); @@ -33862,13 +33862,15 @@ static void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conver { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: { - VkPhysicalDeviceExternalImageFormatInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceExternalImageFormatInfo32 *in_ext = (const VkPhysicalDeviceExternalImageFormatInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO; + VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT; out_ext->pNext = NULL; - out_ext->handleType = in_ext->handleType; + out_ext->flags = in_ext->flags; + out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount; + out_ext->pFixedRateFlags = UlongToPtr(in_ext->pFixedRateFlags); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -33896,49 +33898,47 @@ static void convert_VkPhysicalDeviceImageFormatInfo2_win32_to_host(struct conver out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: + case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: { - VkPhysicalDeviceImageViewImageFormatInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *in_ext = (const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT; + VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV; out_ext->pNext = NULL; - out_ext->imageViewType = in_ext->imageViewType; + out_ext->usage = in_ext->usage; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: { - VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkVideoProfileListInfoKHR32 *in_ext = (const VkVideoProfileListInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; + VkPhysicalDeviceExternalImageFormatInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceExternalImageFormatInfo32 *in_ext = (const VkPhysicalDeviceExternalImageFormatInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO; out_ext->pNext = NULL; - out_ext->profileCount = in_ext->profileCount; - out_ext->pProfiles = convert_VkVideoProfileInfoKHR_array_win32_to_host(ctx, (const VkVideoProfileInfoKHR32 *)UlongToPtr(in_ext->pProfiles), in_ext->profileCount); + out_ext->handleType = in_ext->handleType; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: { - VkImageCompressionControlEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImageCompressionControlEXT32 *in_ext = (const VkImageCompressionControlEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT; + VkPhysicalDeviceImageViewImageFormatInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *in_ext = (const VkPhysicalDeviceImageViewImageFormatInfoEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->compressionControlPlaneCount = in_ext->compressionControlPlaneCount; - out_ext->pFixedRateFlags = UlongToPtr(in_ext->pFixedRateFlags); + out_ext->imageViewType = in_ext->imageViewType; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: { - VkOpticalFlowImageFormatInfoNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkOpticalFlowImageFormatInfoNV32 *in_ext = (const VkOpticalFlowImageFormatInfoNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV; + VkVideoProfileListInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkVideoProfileListInfoKHR32 *in_ext = (const VkVideoProfileListInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR; out_ext->pNext = NULL; - out_ext->usage = in_ext->usage; + out_ext->profileCount = in_ext->profileCount; + out_ext->pProfiles = convert_VkVideoProfileInfoKHR_array_win32_to_host(ctx, (const VkVideoProfileInfoKHR32 *)UlongToPtr(in_ext->pProfiles), in_ext->profileCount); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -33973,24 +33973,6 @@ static void convert_VkImageFormatProperties2_win32_to_host(struct conversion_con out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: - { - VkSamplerYcbcrConversionImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; - out_ext->pNext = NULL; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: - { - VkTextureLODGatherFormatPropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD; - out_ext->pNext = NULL; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: { VkFilterCubicImageViewImageFormatPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -34018,10 +34000,28 @@ static void convert_VkImageFormatProperties2_win32_to_host(struct conversion_con out_header = (void *)out_ext; break; } - default: - FIXME("Unhandled sType %u.\n", in_header->sType); - break; - } + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + { + VkSamplerYcbcrConversionImageFormatProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: + { + VkTextureLODGatherFormatPropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + default: + FIXME("Unhandled sType %u.\n", in_header->sType); + break; + } } }

@@ -34047,24 +34047,6 @@ static void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatPr out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: - { - VkSamplerYcbcrConversionImageFormatProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES); - const VkSamplerYcbcrConversionImageFormatProperties *in_ext = (const VkSamplerYcbcrConversionImageFormatProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; - out_ext->combinedImageSamplerDescriptorCount = in_ext->combinedImageSamplerDescriptorCount; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: - { - VkTextureLODGatherFormatPropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD); - const VkTextureLODGatherFormatPropertiesAMD *in_ext = (const VkTextureLODGatherFormatPropertiesAMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD; - out_ext->supportsTextureGatherLODBiasAMD = in_ext->supportsTextureGatherLODBiasAMD; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: { VkFilterCubicImageViewImageFormatPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT); @@ -34095,6 +34077,24 @@ static void convert_VkImageFormatProperties2_host_to_win32(const VkImageFormatPr out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + { + VkSamplerYcbcrConversionImageFormatProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES); + const VkSamplerYcbcrConversionImageFormatProperties *in_ext = (const VkSamplerYcbcrConversionImageFormatProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES; + out_ext->combinedImageSamplerDescriptorCount = in_ext->combinedImageSamplerDescriptorCount; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: + { + VkTextureLODGatherFormatPropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD); + const VkTextureLODGatherFormatPropertiesAMD *in_ext = (const VkTextureLODGatherFormatPropertiesAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD; + out_ext->supportsTextureGatherLODBiasAMD = in_ext->supportsTextureGatherLODBiasAMD; + out_header = (void *)out_ext; + break; + } default: break; } @@ -34404,523 +34404,525 @@ static void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_ { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: { - VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV; + VkPhysicalDeviceAccelerationStructurePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: { - VkPhysicalDeviceClusterAccelerationStructurePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV; + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV: { - VkPhysicalDeviceMultiDrawPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT; + VkPhysicalDeviceClusterAccelerationStructurePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: { - VkPhysicalDevicePushDescriptorProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES; + VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: { - VkPhysicalDeviceDriverProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; + VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: { - VkPhysicalDeviceIDProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES; + VkPhysicalDeviceConservativeRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: { - VkPhysicalDeviceMultiviewProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; + VkPhysicalDeviceCooperativeMatrix2PropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: { - VkPhysicalDeviceDiscardRectanglePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; + VkPhysicalDeviceCooperativeMatrixPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: { - VkPhysicalDeviceSubgroupProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES; + VkPhysicalDeviceCooperativeMatrixPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV: { - VkPhysicalDevicePointClippingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; + VkPhysicalDeviceCooperativeVectorPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: { - VkPhysicalDeviceProtectedMemoryProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES; + VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: { - VkPhysicalDeviceSamplerFilterMinmaxProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; + VkPhysicalDeviceCustomBorderColorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: { - VkPhysicalDeviceSampleLocationsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT; + VkPhysicalDeviceDepthStencilResolveProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: { - VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT; + VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: { - VkPhysicalDeviceInlineUniformBlockProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; + VkPhysicalDeviceDescriptorBufferPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: { - VkPhysicalDeviceMaintenance3Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; + VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; out_ext->pNext = NULL; + out_ext->tensorCaptureReplayDescriptorDataSize = in_ext->tensorCaptureReplayDescriptorDataSize; + out_ext->tensorViewCaptureReplayDescriptorDataSize = in_ext->tensorViewCaptureReplayDescriptorDataSize; + out_ext->tensorDescriptorSize = in_ext->tensorDescriptorSize; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: { - VkPhysicalDeviceMaintenance4Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; + VkPhysicalDeviceDescriptorIndexingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: { - VkPhysicalDeviceMaintenance5Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES; + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: { - VkPhysicalDeviceMaintenance6Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES; + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: { - VkPhysicalDeviceMaintenance9PropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; + VkPhysicalDeviceDiscardRectanglePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: { - VkPhysicalDeviceFloatControlsProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; + VkPhysicalDeviceDriverProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: { - VkPhysicalDeviceExternalMemoryHostPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; + VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: { - VkPhysicalDeviceConservativeRasterizationPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; + VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: { - VkPhysicalDeviceShaderCorePropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD; + VkPhysicalDeviceExternalMemoryHostPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: { - VkPhysicalDeviceShaderCoreProperties2AMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD; + VkPhysicalDeviceFloatControlsProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: { - VkPhysicalDeviceDescriptorIndexingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; + VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: { - VkPhysicalDeviceTimelineSemaphoreProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; + VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT: { - VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; + VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: { - VkPhysicalDeviceVertexAttributeDivisorProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; + VkPhysicalDeviceFragmentDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: { - VkPhysicalDevicePCIBusInfoPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT; + VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: { - VkPhysicalDeviceDepthStencilResolveProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; + VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: { - VkPhysicalDeviceTransformFeedbackPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; + VkPhysicalDeviceFragmentShadingRatePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: { - VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; - out_ext->pNext = NULL; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: - { - VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV; + VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: { - VkPhysicalDeviceMemoryDecompressionPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV; + VkPhysicalDeviceHostImageCopyProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceHostImageCopyProperties32 *in_ext = (const VkPhysicalDeviceHostImageCopyProperties32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES; out_ext->pNext = NULL; + out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount; + out_ext->pCopySrcLayouts = UlongToPtr(in_ext->pCopySrcLayouts); + out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount; + out_ext->pCopyDstLayouts = UlongToPtr(in_ext->pCopyDstLayouts); + memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t)); + out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: { - VkPhysicalDeviceShadingRateImagePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV; + VkPhysicalDeviceIDProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: { - VkPhysicalDeviceMeshShaderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV; + VkPhysicalDeviceImageAlignmentControlPropertiesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: { - VkPhysicalDeviceMeshShaderPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT; + VkPhysicalDeviceImageProcessing2PropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: { - VkPhysicalDeviceAccelerationStructurePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR; + VkPhysicalDeviceImageProcessingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: { - VkPhysicalDeviceRayTracingPipelinePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR; + VkPhysicalDeviceInlineUniformBlockProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: { - VkPhysicalDeviceRayTracingPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV; + VkPhysicalDeviceLayeredDriverPropertiesMSFT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: { - VkPhysicalDeviceFragmentDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; + VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: { - VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; + VkPhysicalDeviceLineRasterizationProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: { - VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT; + VkPhysicalDeviceMaintenance3Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: { - VkPhysicalDeviceCooperativeMatrixPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV; + VkPhysicalDeviceMaintenance4Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: { - VkPhysicalDevicePerformanceQueryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR; + VkPhysicalDeviceMaintenance5Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: { - VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV; + VkPhysicalDeviceMaintenance6Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: { - VkPhysicalDeviceTexelBufferAlignmentProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; + VkPhysicalDeviceMaintenance9PropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: { - VkPhysicalDeviceSubgroupSizeControlProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; + VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: { - VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI; + VkPhysicalDeviceMemoryDecompressionPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: { - VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI; + VkPhysicalDeviceMeshShaderPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: { - VkPhysicalDeviceLineRasterizationProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES; + VkPhysicalDeviceMeshShaderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: { - VkPhysicalDeviceVulkan11Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; + VkPhysicalDeviceMultiDrawPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: { - VkPhysicalDeviceVulkan12Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; + VkPhysicalDeviceMultiviewProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: { - VkPhysicalDeviceVulkan13Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES; + VkPhysicalDeviceNestedCommandBufferPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: { - VkPhysicalDeviceVulkan14Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES; + VkPhysicalDeviceOpacityMicromapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: { - VkPhysicalDeviceCustomBorderColorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; + VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: { - VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; + VkPhysicalDevicePCIBusInfoPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -34935,367 +34937,365 @@ static void convert_VkPhysicalDeviceProperties2_win32_to_host(struct conversion_ out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: { - VkPhysicalDeviceRobustness2PropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR; + VkPhysicalDevicePerformanceQueryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: { - VkPhysicalDeviceFragmentShadingRatePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; + VkPhysicalDevicePipelineBinaryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: { - VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV; + VkPhysicalDevicePipelineRobustnessProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: { - VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT; + VkPhysicalDevicePointClippingProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: { - VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; + VkPhysicalDeviceProtectedMemoryProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: { - VkPhysicalDeviceHostImageCopyProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceHostImageCopyProperties32 *in_ext = (const VkPhysicalDeviceHostImageCopyProperties32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES; + VkPhysicalDeviceProvokingVertexPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT; out_ext->pNext = NULL; - out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount; - out_ext->pCopySrcLayouts = UlongToPtr(in_ext->pCopySrcLayouts); - out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount; - out_ext->pCopyDstLayouts = UlongToPtr(in_ext->pCopyDstLayouts); - memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t)); - out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: { - VkPhysicalDeviceProvokingVertexPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT; + VkPhysicalDevicePushDescriptorProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: { - VkPhysicalDeviceDescriptorBufferPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; + VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: { - VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; + VkPhysicalDeviceRayTracingPipelinePropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: { - VkPhysicalDeviceShaderIntegerDotProductProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; + VkPhysicalDeviceRayTracingPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: { - VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; + VkPhysicalDeviceRenderPassStripedPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR: { - VkPhysicalDevicePipelineBinaryPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; + VkPhysicalDeviceRobustness2PropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: { - VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; + VkPhysicalDeviceSampleLocationsPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: { - VkPhysicalDeviceNestedCommandBufferPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT; + VkPhysicalDeviceSamplerFilterMinmaxProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: { - VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; + VkPhysicalDeviceSchedulingControlsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: { - VkPhysicalDeviceOpacityMicromapPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; + VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: { - VkPhysicalDevicePipelineRobustnessProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES; + VkPhysicalDeviceShaderCoreProperties2AMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: { - VkPhysicalDeviceImageProcessingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM; + VkPhysicalDeviceShaderCorePropertiesAMD *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: { - VkPhysicalDeviceOpticalFlowPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; + VkPhysicalDeviceShaderCorePropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: { - VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; + VkPhysicalDeviceShaderIntegerDotProductProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: { - VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; + VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: { - VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; + VkPhysicalDeviceShaderObjectPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: { - VkPhysicalDeviceShaderCorePropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM; + VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: { - VkPhysicalDeviceShaderObjectPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; + VkPhysicalDeviceShaderTileImagePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: { - VkPhysicalDeviceShaderTileImagePropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT; + VkPhysicalDeviceShadingRateImagePropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: { - VkPhysicalDeviceCooperativeMatrixPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; + VkPhysicalDeviceSubgroupProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: { - VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32 *in_ext = (const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM; + VkPhysicalDeviceSubgroupSizeControlProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; out_ext->pNext = NULL; - out_ext->queueSubmitBoundary = in_ext->queueSubmitBoundary; - out_ext->tileBufferTransfers = in_ext->tileBufferTransfers; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: { - VkPhysicalDeviceImageProcessing2PropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM; + VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: { - VkPhysicalDeviceLayeredDriverPropertiesMSFT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; + VkPhysicalDeviceTensorPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: { - VkPhysicalDeviceSchedulingControlsPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM; + VkPhysicalDeviceTexelBufferAlignmentProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM: { - VkPhysicalDeviceRenderPassStripedPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM; + VkPhysicalDeviceTileMemoryHeapPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32 *in_ext = (const VkPhysicalDeviceTileMemoryHeapPropertiesQCOM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM; out_ext->pNext = NULL; + out_ext->queueSubmitBoundary = in_ext->queueSubmitBoundary; + out_ext->tileBufferTransfers = in_ext->tileBufferTransfers; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: { - VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; + VkPhysicalDeviceTileShadingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: { - VkPhysicalDeviceImageAlignmentControlPropertiesMESA *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; + VkPhysicalDeviceTimelineSemaphoreProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: { - VkPhysicalDeviceCooperativeMatrix2PropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; + VkPhysicalDeviceTransformFeedbackPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: { - VkPhysicalDeviceCooperativeVectorPropertiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV; + VkPhysicalDeviceVertexAttributeDivisorProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: { - VkPhysicalDeviceTileShadingPropertiesQCOM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM; + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE; + VkPhysicalDeviceVulkan11Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { - VkPhysicalDeviceTensorPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; + VkPhysicalDeviceVulkan12Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: { - VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; + VkPhysicalDeviceVulkan13Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: + { + VkPhysicalDeviceVulkan14Properties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES; out_ext->pNext = NULL; - out_ext->tensorCaptureReplayDescriptorDataSize = in_ext->tensorCaptureReplayDescriptorDataSize; - out_ext->tensorViewCaptureReplayDescriptorDataSize = in_ext->tensorViewCaptureReplayDescriptorDataSize; - out_ext->tensorDescriptorSize = in_ext->tensorDescriptorSize; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -35320,20 +35320,33 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: { - VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV); - const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV; - out_ext->maxGraphicsShaderGroupCount = in_ext->maxGraphicsShaderGroupCount; - out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount; - out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount; - out_ext->maxIndirectCommandsStreamCount = in_ext->maxIndirectCommandsStreamCount; - out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset; - out_ext->maxIndirectCommandsStreamStride = in_ext->maxIndirectCommandsStreamStride; - out_ext->minSequencesCountBufferOffsetAlignment = in_ext->minSequencesCountBufferOffsetAlignment; - out_ext->minSequencesIndexBufferOffsetAlignment = in_ext->minSequencesIndexBufferOffsetAlignment; - out_ext->minIndirectCommandsBufferOffsetAlignment = in_ext->minIndirectCommandsBufferOffsetAlignment; + VkPhysicalDeviceAccelerationStructurePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR); + const VkPhysicalDeviceAccelerationStructurePropertiesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructurePropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR; + out_ext->maxGeometryCount = in_ext->maxGeometryCount; + out_ext->maxInstanceCount = in_ext->maxInstanceCount; + out_ext->maxPrimitiveCount = in_ext->maxPrimitiveCount; + out_ext->maxPerStageDescriptorAccelerationStructures = in_ext->maxPerStageDescriptorAccelerationStructures; + out_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures = in_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures; + out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures; + out_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures = in_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures; + out_ext->minAccelerationStructureScratchOffsetAlignment = in_ext->minAccelerationStructureScratchOffsetAlignment; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: + { + VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT); + const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT; + out_ext->advancedBlendMaxColorAttachments = in_ext->advancedBlendMaxColorAttachments; + out_ext->advancedBlendIndependentBlend = in_ext->advancedBlendIndependentBlend; + out_ext->advancedBlendNonPremultipliedSrcColor = in_ext->advancedBlendNonPremultipliedSrcColor; + out_ext->advancedBlendNonPremultipliedDstColor = in_ext->advancedBlendNonPremultipliedDstColor; + out_ext->advancedBlendCorrelatedOverlap = in_ext->advancedBlendCorrelatedOverlap; + out_ext->advancedBlendAllOperations = in_ext->advancedBlendAllOperations; out_header = (void *)out_ext; break; } @@ -35353,200 +35366,292 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: { - VkPhysicalDeviceMultiDrawPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT); - const VkPhysicalDeviceMultiDrawPropertiesEXT *in_ext = (const VkPhysicalDeviceMultiDrawPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT; - out_ext->maxMultiDrawCount = in_ext->maxMultiDrawCount; + VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI); + const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI; + memcpy(out_ext->maxWorkGroupCount, in_ext->maxWorkGroupCount, 3 * sizeof(uint32_t)); + memcpy(out_ext->maxWorkGroupSize, in_ext->maxWorkGroupSize, 3 * sizeof(uint32_t)); + out_ext->maxOutputClusterCount = in_ext->maxOutputClusterCount; + out_ext->indirectBufferOffsetAlignment = in_ext->indirectBufferOffsetAlignment; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: { - VkPhysicalDevicePushDescriptorProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES); - const VkPhysicalDevicePushDescriptorProperties *in_ext = (const VkPhysicalDevicePushDescriptorProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES; - out_ext->maxPushDescriptors = in_ext->maxPushDescriptors; + VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR); + const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; + out_ext->meshAndTaskShaderDerivatives = in_ext->meshAndTaskShaderDerivatives; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: { - VkPhysicalDeviceDriverProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES); - const VkPhysicalDeviceDriverProperties *in_ext = (const VkPhysicalDeviceDriverProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; - out_ext->driverID = in_ext->driverID; - memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char)); - memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char)); - out_ext->conformanceVersion = in_ext->conformanceVersion; + VkPhysicalDeviceConservativeRasterizationPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT); + const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; + out_ext->primitiveOverestimationSize = in_ext->primitiveOverestimationSize; + out_ext->maxExtraPrimitiveOverestimationSize = in_ext->maxExtraPrimitiveOverestimationSize; + out_ext->extraPrimitiveOverestimationSizeGranularity = in_ext->extraPrimitiveOverestimationSizeGranularity; + out_ext->primitiveUnderestimation = in_ext->primitiveUnderestimation; + out_ext->conservativePointAndLineRasterization = in_ext->conservativePointAndLineRasterization; + out_ext->degenerateTrianglesRasterized = in_ext->degenerateTrianglesRasterized; + out_ext->degenerateLinesRasterized = in_ext->degenerateLinesRasterized; + out_ext->fullyCoveredFragmentShaderInputVariable = in_ext->fullyCoveredFragmentShaderInputVariable; + out_ext->conservativeRasterizationPostDepthCoverage = in_ext->conservativeRasterizationPostDepthCoverage; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: { - VkPhysicalDeviceIDProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES); - const VkPhysicalDeviceIDProperties *in_ext = (const VkPhysicalDeviceIDProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES; - memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t)); - memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t)); - memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t)); - out_ext->deviceNodeMask = in_ext->deviceNodeMask; - out_ext->deviceLUIDValid = in_ext->deviceLUIDValid; + VkPhysicalDeviceCooperativeMatrix2PropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV); + const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; + out_ext->cooperativeMatrixWorkgroupScopeMaxWorkgroupSize = in_ext->cooperativeMatrixWorkgroupScopeMaxWorkgroupSize; + out_ext->cooperativeMatrixFlexibleDimensionsMaxDimension = in_ext->cooperativeMatrixFlexibleDimensionsMaxDimension; + out_ext->cooperativeMatrixWorkgroupScopeReservedSharedMemory = in_ext->cooperativeMatrixWorkgroupScopeReservedSharedMemory; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: { - VkPhysicalDeviceMultiviewProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES); - const VkPhysicalDeviceMultiviewProperties *in_ext = (const VkPhysicalDeviceMultiviewProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; - out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount; - out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex; + VkPhysicalDeviceCooperativeMatrixPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR); + const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; + out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: { - VkPhysicalDeviceDiscardRectanglePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT); - const VkPhysicalDeviceDiscardRectanglePropertiesEXT *in_ext = (const VkPhysicalDeviceDiscardRectanglePropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; - out_ext->maxDiscardRectangles = in_ext->maxDiscardRectangles; + VkPhysicalDeviceCooperativeMatrixPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV); + const VkPhysicalDeviceCooperativeMatrixPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV; + out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV: { - VkPhysicalDeviceSubgroupProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES); - const VkPhysicalDeviceSubgroupProperties *in_ext = (const VkPhysicalDeviceSubgroupProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES; - out_ext->subgroupSize = in_ext->subgroupSize; - out_ext->supportedStages = in_ext->supportedStages; - out_ext->supportedOperations = in_ext->supportedOperations; - out_ext->quadOperationsInAllStages = in_ext->quadOperationsInAllStages; + VkPhysicalDeviceCooperativeVectorPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV); + const VkPhysicalDeviceCooperativeVectorPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeVectorPropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV; + out_ext->cooperativeVectorSupportedStages = in_ext->cooperativeVectorSupportedStages; + out_ext->cooperativeVectorTrainingFloat16Accumulation = in_ext->cooperativeVectorTrainingFloat16Accumulation; + out_ext->cooperativeVectorTrainingFloat32Accumulation = in_ext->cooperativeVectorTrainingFloat32Accumulation; + out_ext->maxCooperativeVectorComponents = in_ext->maxCooperativeVectorComponents; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: { - VkPhysicalDevicePointClippingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES); - const VkPhysicalDevicePointClippingProperties *in_ext = (const VkPhysicalDevicePointClippingProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; - out_ext->pointClippingBehavior = in_ext->pointClippingBehavior; + VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV); + const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV; + out_ext->supportedQueues = in_ext->supportedQueues; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: { - VkPhysicalDeviceProtectedMemoryProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES); - const VkPhysicalDeviceProtectedMemoryProperties *in_ext = (const VkPhysicalDeviceProtectedMemoryProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES; - out_ext->protectedNoFault = in_ext->protectedNoFault; + VkPhysicalDeviceCustomBorderColorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT); + const VkPhysicalDeviceCustomBorderColorPropertiesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; + out_ext->maxCustomBorderColorSamplers = in_ext->maxCustomBorderColorSamplers; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: { - VkPhysicalDeviceSamplerFilterMinmaxProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES); - const VkPhysicalDeviceSamplerFilterMinmaxProperties *in_ext = (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; - out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats; - out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping; + VkPhysicalDeviceDepthStencilResolveProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES); + const VkPhysicalDeviceDepthStencilResolveProperties *in_ext = (const VkPhysicalDeviceDepthStencilResolveProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; + out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes; + out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes; + out_ext->independentResolveNone = in_ext->independentResolveNone; + out_ext->independentResolve = in_ext->independentResolve; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: { - VkPhysicalDeviceSampleLocationsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT); - const VkPhysicalDeviceSampleLocationsPropertiesEXT *in_ext = (const VkPhysicalDeviceSampleLocationsPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT; - out_ext->sampleLocationSampleCounts = in_ext->sampleLocationSampleCounts; - out_ext->maxSampleLocationGridSize = in_ext->maxSampleLocationGridSize; - memcpy(out_ext->sampleLocationCoordinateRange, in_ext->sampleLocationCoordinateRange, 2 * sizeof(float)); - out_ext->sampleLocationSubPixelBits = in_ext->sampleLocationSubPixelBits; - out_ext->variableSampleLocations = in_ext->variableSampleLocations; + VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT); + const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; + out_ext->combinedImageSamplerDensityMapDescriptorSize = in_ext->combinedImageSamplerDensityMapDescriptorSize; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: { - VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT); - const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *in_ext = (const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT; - out_ext->advancedBlendMaxColorAttachments = in_ext->advancedBlendMaxColorAttachments; - out_ext->advancedBlendIndependentBlend = in_ext->advancedBlendIndependentBlend; - out_ext->advancedBlendNonPremultipliedSrcColor = in_ext->advancedBlendNonPremultipliedSrcColor; - out_ext->advancedBlendNonPremultipliedDstColor = in_ext->advancedBlendNonPremultipliedDstColor; - out_ext->advancedBlendCorrelatedOverlap = in_ext->advancedBlendCorrelatedOverlap; - out_ext->advancedBlendAllOperations = in_ext->advancedBlendAllOperations; + VkPhysicalDeviceDescriptorBufferPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT); + const VkPhysicalDeviceDescriptorBufferPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; + out_ext->combinedImageSamplerDescriptorSingleArray = in_ext->combinedImageSamplerDescriptorSingleArray; + out_ext->bufferlessPushDescriptors = in_ext->bufferlessPushDescriptors; + out_ext->allowSamplerImageViewPostSubmitCreation = in_ext->allowSamplerImageViewPostSubmitCreation; + out_ext->descriptorBufferOffsetAlignment = in_ext->descriptorBufferOffsetAlignment; + out_ext->maxDescriptorBufferBindings = in_ext->maxDescriptorBufferBindings; + out_ext->maxResourceDescriptorBufferBindings = in_ext->maxResourceDescriptorBufferBindings; + out_ext->maxSamplerDescriptorBufferBindings = in_ext->maxSamplerDescriptorBufferBindings; + out_ext->maxEmbeddedImmutableSamplerBindings = in_ext->maxEmbeddedImmutableSamplerBindings; + out_ext->maxEmbeddedImmutableSamplers = in_ext->maxEmbeddedImmutableSamplers; + out_ext->bufferCaptureReplayDescriptorDataSize = in_ext->bufferCaptureReplayDescriptorDataSize; + out_ext->imageCaptureReplayDescriptorDataSize = in_ext->imageCaptureReplayDescriptorDataSize; + out_ext->imageViewCaptureReplayDescriptorDataSize = in_ext->imageViewCaptureReplayDescriptorDataSize; + out_ext->samplerCaptureReplayDescriptorDataSize = in_ext->samplerCaptureReplayDescriptorDataSize; + out_ext->accelerationStructureCaptureReplayDescriptorDataSize = in_ext->accelerationStructureCaptureReplayDescriptorDataSize; + out_ext->samplerDescriptorSize = in_ext->samplerDescriptorSize; + out_ext->combinedImageSamplerDescriptorSize = in_ext->combinedImageSamplerDescriptorSize; + out_ext->sampledImageDescriptorSize = in_ext->sampledImageDescriptorSize; + out_ext->storageImageDescriptorSize = in_ext->storageImageDescriptorSize; + out_ext->uniformTexelBufferDescriptorSize = in_ext->uniformTexelBufferDescriptorSize; + out_ext->robustUniformTexelBufferDescriptorSize = in_ext->robustUniformTexelBufferDescriptorSize; + out_ext->storageTexelBufferDescriptorSize = in_ext->storageTexelBufferDescriptorSize; + out_ext->robustStorageTexelBufferDescriptorSize = in_ext->robustStorageTexelBufferDescriptorSize; + out_ext->uniformBufferDescriptorSize = in_ext->uniformBufferDescriptorSize; + out_ext->robustUniformBufferDescriptorSize = in_ext->robustUniformBufferDescriptorSize; + out_ext->storageBufferDescriptorSize = in_ext->storageBufferDescriptorSize; + out_ext->robustStorageBufferDescriptorSize = in_ext->robustStorageBufferDescriptorSize; + out_ext->inputAttachmentDescriptorSize = in_ext->inputAttachmentDescriptorSize; + out_ext->accelerationStructureDescriptorSize = in_ext->accelerationStructureDescriptorSize; + out_ext->maxSamplerDescriptorBufferRange = in_ext->maxSamplerDescriptorBufferRange; + out_ext->maxResourceDescriptorBufferRange = in_ext->maxResourceDescriptorBufferRange; + out_ext->samplerDescriptorBufferAddressSpaceSize = in_ext->samplerDescriptorBufferAddressSpaceSize; + out_ext->resourceDescriptorBufferAddressSpaceSize = in_ext->resourceDescriptorBufferAddressSpaceSize; + out_ext->descriptorBufferAddressSpaceSize = in_ext->descriptorBufferAddressSpaceSize; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: { - VkPhysicalDeviceInlineUniformBlockProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES); - const VkPhysicalDeviceInlineUniformBlockProperties *in_ext = (const VkPhysicalDeviceInlineUniformBlockProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; - out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize; - out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks; - out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; - out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks; - out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM); + const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; + out_ext->tensorCaptureReplayDescriptorDataSize = in_ext->tensorCaptureReplayDescriptorDataSize; + out_ext->tensorViewCaptureReplayDescriptorDataSize = in_ext->tensorViewCaptureReplayDescriptorDataSize; + out_ext->tensorDescriptorSize = in_ext->tensorDescriptorSize; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: { - VkPhysicalDeviceMaintenance3Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES); - const VkPhysicalDeviceMaintenance3Properties *in_ext = (const VkPhysicalDeviceMaintenance3Properties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; - out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors; - out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize; + VkPhysicalDeviceDescriptorIndexingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES); + const VkPhysicalDeviceDescriptorIndexingProperties *in_ext = (const VkPhysicalDeviceDescriptorIndexingProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; + out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools; + out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative; + out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative; + out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative; + out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative; + out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative; + out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind; + out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod; + out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers; + out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers; + out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers; + out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages; + out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages; + out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments; + out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources; + out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers; + out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers; + out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers; + out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages; + out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages; + out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: { - VkPhysicalDeviceMaintenance4Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES); - const VkPhysicalDeviceMaintenance4Properties *in_ext = (const VkPhysicalDeviceMaintenance4Properties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; - out_ext->maxBufferSize = in_ext->maxBufferSize; + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT); + const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; + out_ext->maxIndirectPipelineCount = in_ext->maxIndirectPipelineCount; + out_ext->maxIndirectShaderObjectCount = in_ext->maxIndirectShaderObjectCount; + out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount; + out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount; + out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset; + out_ext->maxIndirectCommandsIndirectStride = in_ext->maxIndirectCommandsIndirectStride; + out_ext->supportedIndirectCommandsInputModes = in_ext->supportedIndirectCommandsInputModes; + out_ext->supportedIndirectCommandsShaderStages = in_ext->supportedIndirectCommandsShaderStages; + out_ext->supportedIndirectCommandsShaderStagesPipelineBinding = in_ext->supportedIndirectCommandsShaderStagesPipelineBinding; + out_ext->supportedIndirectCommandsShaderStagesShaderBinding = in_ext->supportedIndirectCommandsShaderStagesShaderBinding; + out_ext->deviceGeneratedCommandsTransformFeedback = in_ext->deviceGeneratedCommandsTransformFeedback; + out_ext->deviceGeneratedCommandsMultiDrawIndirectCount = in_ext->deviceGeneratedCommandsMultiDrawIndirectCount; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: { - VkPhysicalDeviceMaintenance5Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES); - const VkPhysicalDeviceMaintenance5Properties *in_ext = (const VkPhysicalDeviceMaintenance5Properties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES; - out_ext->earlyFragmentMultisampleCoverageAfterSampleCounting = in_ext->earlyFragmentMultisampleCoverageAfterSampleCounting; - out_ext->earlyFragmentSampleMaskTestBeforeSampleCounting = in_ext->earlyFragmentSampleMaskTestBeforeSampleCounting; - out_ext->depthStencilSwizzleOneSupport = in_ext->depthStencilSwizzleOneSupport; - out_ext->polygonModePointSize = in_ext->polygonModePointSize; - out_ext->nonStrictSinglePixelWideLinesUseParallelogram = in_ext->nonStrictSinglePixelWideLinesUseParallelogram; - out_ext->nonStrictWideLinesUseParallelogram = in_ext->nonStrictWideLinesUseParallelogram; + VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV); + const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV; + out_ext->maxGraphicsShaderGroupCount = in_ext->maxGraphicsShaderGroupCount; + out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount; + out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount; + out_ext->maxIndirectCommandsStreamCount = in_ext->maxIndirectCommandsStreamCount; + out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset; + out_ext->maxIndirectCommandsStreamStride = in_ext->maxIndirectCommandsStreamStride; + out_ext->minSequencesCountBufferOffsetAlignment = in_ext->minSequencesCountBufferOffsetAlignment; + out_ext->minSequencesIndexBufferOffsetAlignment = in_ext->minSequencesIndexBufferOffsetAlignment; + out_ext->minIndirectCommandsBufferOffsetAlignment = in_ext->minIndirectCommandsBufferOffsetAlignment; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: { - VkPhysicalDeviceMaintenance6Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES); - const VkPhysicalDeviceMaintenance6Properties *in_ext = (const VkPhysicalDeviceMaintenance6Properties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES; - out_ext->blockTexelViewCompatibleMultipleLayers = in_ext->blockTexelViewCompatibleMultipleLayers; - out_ext->maxCombinedImageSamplerDescriptorCount = in_ext->maxCombinedImageSamplerDescriptorCount; - out_ext->fragmentShadingRateClampCombinerInputs = in_ext->fragmentShadingRateClampCombinerInputs; + VkPhysicalDeviceDiscardRectanglePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT); + const VkPhysicalDeviceDiscardRectanglePropertiesEXT *in_ext = (const VkPhysicalDeviceDiscardRectanglePropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT; + out_ext->maxDiscardRectangles = in_ext->maxDiscardRectangles; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: { - VkPhysicalDeviceMaintenance9PropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR); - const VkPhysicalDeviceMaintenance9PropertiesKHR *in_ext = (const VkPhysicalDeviceMaintenance9PropertiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; - out_ext->image2DViewOf3DSparse = in_ext->image2DViewOf3DSparse; - out_ext->defaultVertexAttributeValue = in_ext->defaultVertexAttributeValue; - out_header = (void *)out_ext; + VkPhysicalDeviceDriverProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES); + const VkPhysicalDeviceDriverProperties *in_ext = (const VkPhysicalDeviceDriverProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; + out_ext->driverID = in_ext->driverID; + memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char)); + memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char)); + out_ext->conformanceVersion = in_ext->conformanceVersion; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: + { + VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT); + const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; + out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: + { + VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV); + const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; + out_ext->extendedSparseAddressSpaceSize = in_ext->extendedSparseAddressSpaceSize; + out_ext->extendedSparseImageUsageFlags = in_ext->extendedSparseImageUsageFlags; + out_ext->extendedSparseBufferUsageFlags = in_ext->extendedSparseBufferUsageFlags; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: + { + VkPhysicalDeviceExternalMemoryHostPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT); + const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *in_ext = (const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; + out_ext->minImportedHostPointerAlignment = in_ext->minImportedHostPointerAlignment; + out_header = (void *)out_ext; break; } case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: @@ -35574,222 +35679,267 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: { - VkPhysicalDeviceExternalMemoryHostPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT); - const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *in_ext = (const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT; - out_ext->minImportedHostPointerAlignment = in_ext->minImportedHostPointerAlignment; + VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT); + const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; + out_ext->subsampledLoads = in_ext->subsampledLoads; + out_ext->subsampledCoarseReconstructionEarlyAccess = in_ext->subsampledCoarseReconstructionEarlyAccess; + out_ext->maxSubsampledArrayLayers = in_ext->maxSubsampledArrayLayers; + out_ext->maxDescriptorSetSubsampledSamplers = in_ext->maxDescriptorSetSubsampledSamplers; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: { - VkPhysicalDeviceConservativeRasterizationPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT); - const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *in_ext = (const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT; - out_ext->primitiveOverestimationSize = in_ext->primitiveOverestimationSize; - out_ext->maxExtraPrimitiveOverestimationSize = in_ext->maxExtraPrimitiveOverestimationSize; - out_ext->extraPrimitiveOverestimationSizeGranularity = in_ext->extraPrimitiveOverestimationSizeGranularity; - out_ext->primitiveUnderestimation = in_ext->primitiveUnderestimation; - out_ext->conservativePointAndLineRasterization = in_ext->conservativePointAndLineRasterization; - out_ext->degenerateTrianglesRasterized = in_ext->degenerateTrianglesRasterized; - out_ext->degenerateLinesRasterized = in_ext->degenerateLinesRasterized; - out_ext->fullyCoveredFragmentShaderInputVariable = in_ext->fullyCoveredFragmentShaderInputVariable; - out_ext->conservativeRasterizationPostDepthCoverage = in_ext->conservativeRasterizationPostDepthCoverage; + VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE); + const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *in_ext = (const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE; + out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT: { - VkPhysicalDeviceShaderCorePropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD); - const VkPhysicalDeviceShaderCorePropertiesAMD *in_ext = (const VkPhysicalDeviceShaderCorePropertiesAMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD; - out_ext->shaderEngineCount = in_ext->shaderEngineCount; - out_ext->shaderArraysPerEngineCount = in_ext->shaderArraysPerEngineCount; - out_ext->computeUnitsPerShaderArray = in_ext->computeUnitsPerShaderArray; - out_ext->simdPerComputeUnit = in_ext->simdPerComputeUnit; - out_ext->wavefrontsPerSimd = in_ext->wavefrontsPerSimd; - out_ext->wavefrontSize = in_ext->wavefrontSize; - out_ext->sgprsPerSimd = in_ext->sgprsPerSimd; - out_ext->minSgprAllocation = in_ext->minSgprAllocation; - out_ext->maxSgprAllocation = in_ext->maxSgprAllocation; - out_ext->sgprAllocationGranularity = in_ext->sgprAllocationGranularity; - out_ext->vgprsPerSimd = in_ext->vgprsPerSimd; - out_ext->minVgprAllocation = in_ext->minVgprAllocation; - out_ext->maxVgprAllocation = in_ext->maxVgprAllocation; - out_ext->vgprAllocationGranularity = in_ext->vgprAllocationGranularity; + VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT); + const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT; + out_ext->fragmentDensityOffsetGranularity = in_ext->fragmentDensityOffsetGranularity; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: { - VkPhysicalDeviceShaderCoreProperties2AMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD); - const VkPhysicalDeviceShaderCoreProperties2AMD *in_ext = (const VkPhysicalDeviceShaderCoreProperties2AMD *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD; - out_ext->shaderCoreFeatures = in_ext->shaderCoreFeatures; - out_ext->activeComputeUnitCount = in_ext->activeComputeUnitCount; + VkPhysicalDeviceFragmentDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT); + const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; + out_ext->minFragmentDensityTexelSize = in_ext->minFragmentDensityTexelSize; + out_ext->maxFragmentDensityTexelSize = in_ext->maxFragmentDensityTexelSize; + out_ext->fragmentDensityInvocations = in_ext->fragmentDensityInvocations; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: { - VkPhysicalDeviceDescriptorIndexingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES); - const VkPhysicalDeviceDescriptorIndexingProperties *in_ext = (const VkPhysicalDeviceDescriptorIndexingProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES; - out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools; - out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative; - out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative; - out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative; - out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative; - out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative; - out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind; - out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod; - out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers; - out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers; - out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers; - out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages; - out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages; - out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments; - out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources; - out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers; - out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers; - out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers; - out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages; - out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages; - out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments; + VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR); + const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; + out_ext->triStripVertexOrderIndependentOfProvokingVertex = in_ext->triStripVertexOrderIndependentOfProvokingVertex; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: { - VkPhysicalDeviceTimelineSemaphoreProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES); - const VkPhysicalDeviceTimelineSemaphoreProperties *in_ext = (const VkPhysicalDeviceTimelineSemaphoreProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; - out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference; + VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV); + const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV; + out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: { - VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT); - const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; - out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor; + VkPhysicalDeviceFragmentShadingRatePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR); + const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; + out_ext->minFragmentShadingRateAttachmentTexelSize = in_ext->minFragmentShadingRateAttachmentTexelSize; + out_ext->maxFragmentShadingRateAttachmentTexelSize = in_ext->maxFragmentShadingRateAttachmentTexelSize; + out_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio; + out_ext->primitiveFragmentShadingRateWithMultipleViewports = in_ext->primitiveFragmentShadingRateWithMultipleViewports; + out_ext->layeredShadingRateAttachments = in_ext->layeredShadingRateAttachments; + out_ext->fragmentShadingRateNonTrivialCombinerOps = in_ext->fragmentShadingRateNonTrivialCombinerOps; + out_ext->maxFragmentSize = in_ext->maxFragmentSize; + out_ext->maxFragmentSizeAspectRatio = in_ext->maxFragmentSizeAspectRatio; + out_ext->maxFragmentShadingRateCoverageSamples = in_ext->maxFragmentShadingRateCoverageSamples; + out_ext->maxFragmentShadingRateRasterizationSamples = in_ext->maxFragmentShadingRateRasterizationSamples; + out_ext->fragmentShadingRateWithShaderDepthStencilWrites = in_ext->fragmentShadingRateWithShaderDepthStencilWrites; + out_ext->fragmentShadingRateWithSampleMask = in_ext->fragmentShadingRateWithSampleMask; + out_ext->fragmentShadingRateWithShaderSampleMask = in_ext->fragmentShadingRateWithShaderSampleMask; + out_ext->fragmentShadingRateWithConservativeRasterization = in_ext->fragmentShadingRateWithConservativeRasterization; + out_ext->fragmentShadingRateWithFragmentShaderInterlock = in_ext->fragmentShadingRateWithFragmentShaderInterlock; + out_ext->fragmentShadingRateWithCustomSampleLocations = in_ext->fragmentShadingRateWithCustomSampleLocations; + out_ext->fragmentShadingRateStrictMultiplyCombiner = in_ext->fragmentShadingRateStrictMultiplyCombiner; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: { - VkPhysicalDeviceVertexAttributeDivisorProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES); - const VkPhysicalDeviceVertexAttributeDivisorProperties *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; - out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor; - out_ext->supportsNonZeroFirstInstance = in_ext->supportsNonZeroFirstInstance; + VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT); + const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; + out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking; + out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: { - VkPhysicalDevicePCIBusInfoPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT); - const VkPhysicalDevicePCIBusInfoPropertiesEXT *in_ext = (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT; - out_ext->pciDomain = in_ext->pciDomain; - out_ext->pciBus = in_ext->pciBus; - out_ext->pciDevice = in_ext->pciDevice; - out_ext->pciFunction = in_ext->pciFunction; + VkPhysicalDeviceHostImageCopyProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES); + const VkPhysicalDeviceHostImageCopyProperties *in_ext = (const VkPhysicalDeviceHostImageCopyProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES; + out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount; + out_ext->pCopySrcLayouts = PtrToUlong(in_ext->pCopySrcLayouts); + out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount; + out_ext->pCopyDstLayouts = PtrToUlong(in_ext->pCopyDstLayouts); + memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t)); + out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: { - VkPhysicalDeviceDepthStencilResolveProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES); - const VkPhysicalDeviceDepthStencilResolveProperties *in_ext = (const VkPhysicalDeviceDepthStencilResolveProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES; - out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes; - out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes; - out_ext->independentResolveNone = in_ext->independentResolveNone; - out_ext->independentResolve = in_ext->independentResolve; + VkPhysicalDeviceIDProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES); + const VkPhysicalDeviceIDProperties *in_ext = (const VkPhysicalDeviceIDProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES; + memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t)); + memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t)); + memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t)); + out_ext->deviceNodeMask = in_ext->deviceNodeMask; + out_ext->deviceLUIDValid = in_ext->deviceLUIDValid; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: { - VkPhysicalDeviceTransformFeedbackPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT); - const VkPhysicalDeviceTransformFeedbackPropertiesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; - out_ext->maxTransformFeedbackStreams = in_ext->maxTransformFeedbackStreams; - out_ext->maxTransformFeedbackBuffers = in_ext->maxTransformFeedbackBuffers; - out_ext->maxTransformFeedbackBufferSize = in_ext->maxTransformFeedbackBufferSize; - out_ext->maxTransformFeedbackStreamDataSize = in_ext->maxTransformFeedbackStreamDataSize; - out_ext->maxTransformFeedbackBufferDataSize = in_ext->maxTransformFeedbackBufferDataSize; - out_ext->maxTransformFeedbackBufferDataStride = in_ext->maxTransformFeedbackBufferDataStride; - out_ext->transformFeedbackQueries = in_ext->transformFeedbackQueries; - out_ext->transformFeedbackStreamsLinesTriangles = in_ext->transformFeedbackStreamsLinesTriangles; - out_ext->transformFeedbackRasterizationStreamSelect = in_ext->transformFeedbackRasterizationStreamSelect; - out_ext->transformFeedbackDraw = in_ext->transformFeedbackDraw; + VkPhysicalDeviceImageAlignmentControlPropertiesMESA32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA); + const VkPhysicalDeviceImageAlignmentControlPropertiesMESA *in_ext = (const VkPhysicalDeviceImageAlignmentControlPropertiesMESA *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; + out_ext->supportedImageAlignmentMask = in_ext->supportedImageAlignmentMask; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: { - VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR); - const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *in_ext = (const VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR; - out_ext->meshAndTaskShaderDerivatives = in_ext->meshAndTaskShaderDerivatives; + VkPhysicalDeviceImageProcessing2PropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM); + const VkPhysicalDeviceImageProcessing2PropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing2PropertiesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM; + out_ext->maxBlockMatchWindow = in_ext->maxBlockMatchWindow; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: { - VkPhysicalDeviceCopyMemoryIndirectPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV); - const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *in_ext = (const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV; - out_ext->supportedQueues = in_ext->supportedQueues; - out_header = (void *)out_ext; - break; + VkPhysicalDeviceImageProcessingPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM); + const VkPhysicalDeviceImageProcessingPropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingPropertiesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM; + out_ext->maxWeightFilterPhases = in_ext->maxWeightFilterPhases; + out_ext->maxWeightFilterDimension = in_ext->maxWeightFilterDimension; + out_ext->maxBlockMatchRegion = in_ext->maxBlockMatchRegion; + out_ext->maxBoxFilterBlockSize = in_ext->maxBoxFilterBlockSize; + out_header = (void *)out_ext; + break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: { - VkPhysicalDeviceMemoryDecompressionPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV); - const VkPhysicalDeviceMemoryDecompressionPropertiesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionPropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV; - out_ext->decompressionMethods = in_ext->decompressionMethods; - out_ext->maxDecompressionIndirectCount = in_ext->maxDecompressionIndirectCount; + VkPhysicalDeviceInlineUniformBlockProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES); + const VkPhysicalDeviceInlineUniformBlockProperties *in_ext = (const VkPhysicalDeviceInlineUniformBlockProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES; + out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize; + out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks; + out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks; + out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: { - VkPhysicalDeviceShadingRateImagePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV); - const VkPhysicalDeviceShadingRateImagePropertiesNV *in_ext = (const VkPhysicalDeviceShadingRateImagePropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV; - out_ext->shadingRateTexelSize = in_ext->shadingRateTexelSize; - out_ext->shadingRatePaletteSize = in_ext->shadingRatePaletteSize; - out_ext->shadingRateMaxCoarseSamples = in_ext->shadingRateMaxCoarseSamples; + VkPhysicalDeviceLayeredDriverPropertiesMSFT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT); + const VkPhysicalDeviceLayeredDriverPropertiesMSFT *in_ext = (const VkPhysicalDeviceLayeredDriverPropertiesMSFT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; + out_ext->underlyingAPI = in_ext->underlyingAPI; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: { - VkPhysicalDeviceMeshShaderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV); - const VkPhysicalDeviceMeshShaderPropertiesNV *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV; - out_ext->maxDrawMeshTasksCount = in_ext->maxDrawMeshTasksCount; - out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations; - memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t)); - out_ext->maxTaskTotalMemorySize = in_ext->maxTaskTotalMemorySize; - out_ext->maxTaskOutputCount = in_ext->maxTaskOutputCount; - out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations; - memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t)); - out_ext->maxMeshTotalMemorySize = in_ext->maxMeshTotalMemorySize; - out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices; - out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives; - out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount; - out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity; - out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity; + VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT); + const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT; + out_ext->nativeUnalignedPerformance = in_ext->nativeUnalignedPerformance; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: + { + VkPhysicalDeviceLineRasterizationProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES); + const VkPhysicalDeviceLineRasterizationProperties *in_ext = (const VkPhysicalDeviceLineRasterizationProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES; + out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + { + VkPhysicalDeviceMaintenance3Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES); + const VkPhysicalDeviceMaintenance3Properties *in_ext = (const VkPhysicalDeviceMaintenance3Properties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; + out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors; + out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + { + VkPhysicalDeviceMaintenance4Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES); + const VkPhysicalDeviceMaintenance4Properties *in_ext = (const VkPhysicalDeviceMaintenance4Properties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES; + out_ext->maxBufferSize = in_ext->maxBufferSize; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: + { + VkPhysicalDeviceMaintenance5Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES); + const VkPhysicalDeviceMaintenance5Properties *in_ext = (const VkPhysicalDeviceMaintenance5Properties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES; + out_ext->earlyFragmentMultisampleCoverageAfterSampleCounting = in_ext->earlyFragmentMultisampleCoverageAfterSampleCounting; + out_ext->earlyFragmentSampleMaskTestBeforeSampleCounting = in_ext->earlyFragmentSampleMaskTestBeforeSampleCounting; + out_ext->depthStencilSwizzleOneSupport = in_ext->depthStencilSwizzleOneSupport; + out_ext->polygonModePointSize = in_ext->polygonModePointSize; + out_ext->nonStrictSinglePixelWideLinesUseParallelogram = in_ext->nonStrictSinglePixelWideLinesUseParallelogram; + out_ext->nonStrictWideLinesUseParallelogram = in_ext->nonStrictWideLinesUseParallelogram; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: + { + VkPhysicalDeviceMaintenance6Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES); + const VkPhysicalDeviceMaintenance6Properties *in_ext = (const VkPhysicalDeviceMaintenance6Properties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES; + out_ext->blockTexelViewCompatibleMultipleLayers = in_ext->blockTexelViewCompatibleMultipleLayers; + out_ext->maxCombinedImageSamplerDescriptorCount = in_ext->maxCombinedImageSamplerDescriptorCount; + out_ext->fragmentShadingRateClampCombinerInputs = in_ext->fragmentShadingRateClampCombinerInputs; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: + { + VkPhysicalDeviceMaintenance9PropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR); + const VkPhysicalDeviceMaintenance9PropertiesKHR *in_ext = (const VkPhysicalDeviceMaintenance9PropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR; + out_ext->image2DViewOf3DSparse = in_ext->image2DViewOf3DSparse; + out_ext->defaultVertexAttributeValue = in_ext->defaultVertexAttributeValue; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: + { + VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT); + const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; + out_ext->minPlacedMemoryMapAlignment = in_ext->minPlacedMemoryMapAlignment; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: + { + VkPhysicalDeviceMemoryDecompressionPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV); + const VkPhysicalDeviceMemoryDecompressionPropertiesNV *in_ext = (const VkPhysicalDeviceMemoryDecompressionPropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV; + out_ext->decompressionMethods = in_ext->decompressionMethods; + out_ext->maxDecompressionIndirectCount = in_ext->maxDecompressionIndirectCount; out_header = (void *)out_ext; break; } @@ -35829,92 +35979,102 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: { - VkPhysicalDeviceAccelerationStructurePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR); - const VkPhysicalDeviceAccelerationStructurePropertiesKHR *in_ext = (const VkPhysicalDeviceAccelerationStructurePropertiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR; - out_ext->maxGeometryCount = in_ext->maxGeometryCount; - out_ext->maxInstanceCount = in_ext->maxInstanceCount; - out_ext->maxPrimitiveCount = in_ext->maxPrimitiveCount; - out_ext->maxPerStageDescriptorAccelerationStructures = in_ext->maxPerStageDescriptorAccelerationStructures; - out_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures = in_ext->maxPerStageDescriptorUpdateAfterBindAccelerationStructures; - out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures; - out_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures = in_ext->maxDescriptorSetUpdateAfterBindAccelerationStructures; - out_ext->minAccelerationStructureScratchOffsetAlignment = in_ext->minAccelerationStructureScratchOffsetAlignment; + VkPhysicalDeviceMeshShaderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV); + const VkPhysicalDeviceMeshShaderPropertiesNV *in_ext = (const VkPhysicalDeviceMeshShaderPropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV; + out_ext->maxDrawMeshTasksCount = in_ext->maxDrawMeshTasksCount; + out_ext->maxTaskWorkGroupInvocations = in_ext->maxTaskWorkGroupInvocations; + memcpy(out_ext->maxTaskWorkGroupSize, in_ext->maxTaskWorkGroupSize, 3 * sizeof(uint32_t)); + out_ext->maxTaskTotalMemorySize = in_ext->maxTaskTotalMemorySize; + out_ext->maxTaskOutputCount = in_ext->maxTaskOutputCount; + out_ext->maxMeshWorkGroupInvocations = in_ext->maxMeshWorkGroupInvocations; + memcpy(out_ext->maxMeshWorkGroupSize, in_ext->maxMeshWorkGroupSize, 3 * sizeof(uint32_t)); + out_ext->maxMeshTotalMemorySize = in_ext->maxMeshTotalMemorySize; + out_ext->maxMeshOutputVertices = in_ext->maxMeshOutputVertices; + out_ext->maxMeshOutputPrimitives = in_ext->maxMeshOutputPrimitives; + out_ext->maxMeshMultiviewViewCount = in_ext->maxMeshMultiviewViewCount; + out_ext->meshOutputPerVertexGranularity = in_ext->meshOutputPerVertexGranularity; + out_ext->meshOutputPerPrimitiveGranularity = in_ext->meshOutputPerPrimitiveGranularity; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: { - VkPhysicalDeviceRayTracingPipelinePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR); - const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR; - out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize; - out_ext->maxRayRecursionDepth = in_ext->maxRayRecursionDepth; - out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride; - out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment; - out_ext->shaderGroupHandleCaptureReplaySize = in_ext->shaderGroupHandleCaptureReplaySize; - out_ext->maxRayDispatchInvocationCount = in_ext->maxRayDispatchInvocationCount; - out_ext->shaderGroupHandleAlignment = in_ext->shaderGroupHandleAlignment; - out_ext->maxRayHitAttributeSize = in_ext->maxRayHitAttributeSize; + VkPhysicalDeviceMultiDrawPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT); + const VkPhysicalDeviceMultiDrawPropertiesEXT *in_ext = (const VkPhysicalDeviceMultiDrawPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT; + out_ext->maxMultiDrawCount = in_ext->maxMultiDrawCount; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: { - VkPhysicalDeviceRayTracingPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV); - const VkPhysicalDeviceRayTracingPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingPropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV; - out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize; - out_ext->maxRecursionDepth = in_ext->maxRecursionDepth; - out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride; - out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment; - out_ext->maxGeometryCount = in_ext->maxGeometryCount; - out_ext->maxInstanceCount = in_ext->maxInstanceCount; - out_ext->maxTriangleCount = in_ext->maxTriangleCount; - out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures; + VkPhysicalDeviceMultiviewProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES); + const VkPhysicalDeviceMultiviewProperties *in_ext = (const VkPhysicalDeviceMultiviewProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES; + out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount; + out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: { - VkPhysicalDeviceFragmentDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT); - const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT; - out_ext->minFragmentDensityTexelSize = in_ext->minFragmentDensityTexelSize; - out_ext->maxFragmentDensityTexelSize = in_ext->maxFragmentDensityTexelSize; - out_ext->fragmentDensityInvocations = in_ext->fragmentDensityInvocations; + VkPhysicalDeviceNestedCommandBufferPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT); + const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *in_ext = (const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT; + out_ext->maxCommandBufferNestingLevel = in_ext->maxCommandBufferNestingLevel; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: { - VkPhysicalDeviceFragmentDensityMap2PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT); - const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT; - out_ext->subsampledLoads = in_ext->subsampledLoads; - out_ext->subsampledCoarseReconstructionEarlyAccess = in_ext->subsampledCoarseReconstructionEarlyAccess; - out_ext->maxSubsampledArrayLayers = in_ext->maxSubsampledArrayLayers; - out_ext->maxDescriptorSetSubsampledSamplers = in_ext->maxDescriptorSetSubsampledSamplers; + VkPhysicalDeviceOpacityMicromapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT); + const VkPhysicalDeviceOpacityMicromapPropertiesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; + out_ext->maxOpacity2StateSubdivisionLevel = in_ext->maxOpacity2StateSubdivisionLevel; + out_ext->maxOpacity4StateSubdivisionLevel = in_ext->maxOpacity4StateSubdivisionLevel; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: { - VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT); - const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *in_ext = (const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT; - out_ext->fragmentDensityOffsetGranularity = in_ext->fragmentDensityOffsetGranularity; + VkPhysicalDeviceOpticalFlowPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV); + const VkPhysicalDeviceOpticalFlowPropertiesNV *in_ext = (const VkPhysicalDeviceOpticalFlowPropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; + out_ext->supportedOutputGridSizes = in_ext->supportedOutputGridSizes; + out_ext->supportedHintGridSizes = in_ext->supportedHintGridSizes; + out_ext->hintSupported = in_ext->hintSupported; + out_ext->costSupported = in_ext->costSupported; + out_ext->bidirectionalFlowSupported = in_ext->bidirectionalFlowSupported; + out_ext->globalFlowSupported = in_ext->globalFlowSupported; + out_ext->minWidth = in_ext->minWidth; + out_ext->minHeight = in_ext->minHeight; + out_ext->maxWidth = in_ext->maxWidth; + out_ext->maxHeight = in_ext->maxHeight; + out_ext->maxNumRegionsOfInterest = in_ext->maxNumRegionsOfInterest; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: { - VkPhysicalDeviceCooperativeMatrixPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV); - const VkPhysicalDeviceCooperativeMatrixPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV; - out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages; + VkPhysicalDevicePCIBusInfoPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT); + const VkPhysicalDevicePCIBusInfoPropertiesEXT *in_ext = (const VkPhysicalDevicePCIBusInfoPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT; + out_ext->pciDomain = in_ext->pciDomain; + out_ext->pciBus = in_ext->pciBus; + out_ext->pciDevice = in_ext->pciDevice; + out_ext->pciFunction = in_ext->pciFunction; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV: + { + VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV); + const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV; + out_ext->maxPartitionCount = in_ext->maxPartitionCount; out_header = (void *)out_ext; break; } @@ -35927,263 +36087,116 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: { - VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV); - const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV; - out_ext->shaderSMCount = in_ext->shaderSMCount; - out_ext->shaderWarpsPerSM = in_ext->shaderWarpsPerSM; + VkPhysicalDevicePipelineBinaryPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR); + const VkPhysicalDevicePipelineBinaryPropertiesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; + out_ext->pipelineBinaryInternalCache = in_ext->pipelineBinaryInternalCache; + out_ext->pipelineBinaryInternalCacheControl = in_ext->pipelineBinaryInternalCacheControl; + out_ext->pipelineBinaryPrefersInternalCache = in_ext->pipelineBinaryPrefersInternalCache; + out_ext->pipelineBinaryPrecompiledInternalCache = in_ext->pipelineBinaryPrecompiledInternalCache; + out_ext->pipelineBinaryCompressedData = in_ext->pipelineBinaryCompressedData; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: { - VkPhysicalDeviceTexelBufferAlignmentProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES); - const VkPhysicalDeviceTexelBufferAlignmentProperties *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; - out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes; - out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment; - out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes; - out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment; + VkPhysicalDevicePipelineRobustnessProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES); + const VkPhysicalDevicePipelineRobustnessProperties *in_ext = (const VkPhysicalDevicePipelineRobustnessProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES; + out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers; + out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers; + out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs; + out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: { - VkPhysicalDeviceSubgroupSizeControlProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES); - const VkPhysicalDeviceSubgroupSizeControlProperties *in_ext = (const VkPhysicalDeviceSubgroupSizeControlProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; - out_ext->minSubgroupSize = in_ext->minSubgroupSize; - out_ext->maxSubgroupSize = in_ext->maxSubgroupSize; - out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups; - out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages; + VkPhysicalDevicePointClippingProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES); + const VkPhysicalDevicePointClippingProperties *in_ext = (const VkPhysicalDevicePointClippingProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES; + out_ext->pointClippingBehavior = in_ext->pointClippingBehavior; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: { - VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI); - const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI; - out_ext->maxSubpassShadingWorkgroupSizeAspectRatio = in_ext->maxSubpassShadingWorkgroupSizeAspectRatio; + VkPhysicalDeviceProtectedMemoryProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES); + const VkPhysicalDeviceProtectedMemoryProperties *in_ext = (const VkPhysicalDeviceProtectedMemoryProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES; + out_ext->protectedNoFault = in_ext->protectedNoFault; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: { - VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI); - const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI; - memcpy(out_ext->maxWorkGroupCount, in_ext->maxWorkGroupCount, 3 * sizeof(uint32_t)); - memcpy(out_ext->maxWorkGroupSize, in_ext->maxWorkGroupSize, 3 * sizeof(uint32_t)); - out_ext->maxOutputClusterCount = in_ext->maxOutputClusterCount; - out_ext->indirectBufferOffsetAlignment = in_ext->indirectBufferOffsetAlignment; + VkPhysicalDeviceProvokingVertexPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT); + const VkPhysicalDeviceProvokingVertexPropertiesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT; + out_ext->provokingVertexModePerPipeline = in_ext->provokingVertexModePerPipeline; + out_ext->transformFeedbackPreservesTriangleFanProvokingVertex = in_ext->transformFeedbackPreservesTriangleFanProvokingVertex; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: { - VkPhysicalDeviceLineRasterizationProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES); - const VkPhysicalDeviceLineRasterizationProperties *in_ext = (const VkPhysicalDeviceLineRasterizationProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES; - out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits; + VkPhysicalDevicePushDescriptorProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES); + const VkPhysicalDevicePushDescriptorProperties *in_ext = (const VkPhysicalDevicePushDescriptorProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES; + out_ext->maxPushDescriptors = in_ext->maxPushDescriptors; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: { - VkPhysicalDeviceVulkan11Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES); - const VkPhysicalDeviceVulkan11Properties *in_ext = (const VkPhysicalDeviceVulkan11Properties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; - memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t)); - memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t)); - memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t)); - out_ext->deviceNodeMask = in_ext->deviceNodeMask; - out_ext->deviceLUIDValid = in_ext->deviceLUIDValid; - out_ext->subgroupSize = in_ext->subgroupSize; - out_ext->subgroupSupportedStages = in_ext->subgroupSupportedStages; - out_ext->subgroupSupportedOperations = in_ext->subgroupSupportedOperations; - out_ext->subgroupQuadOperationsInAllStages = in_ext->subgroupQuadOperationsInAllStages; - out_ext->pointClippingBehavior = in_ext->pointClippingBehavior; - out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount; - out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex; - out_ext->protectedNoFault = in_ext->protectedNoFault; - out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors; - out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize; + VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV); + const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; + out_ext->rayTracingInvocationReorderReorderingHint = in_ext->rayTracingInvocationReorderReorderingHint; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: { - VkPhysicalDeviceVulkan12Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES); - const VkPhysicalDeviceVulkan12Properties *in_ext = (const VkPhysicalDeviceVulkan12Properties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; - out_ext->driverID = in_ext->driverID; - memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char)); - memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char)); - out_ext->conformanceVersion = in_ext->conformanceVersion; - out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence; - out_ext->roundingModeIndependence = in_ext->roundingModeIndependence; - out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16; - out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32; - out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64; - out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16; - out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32; - out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64; - out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16; - out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32; - out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64; - out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16; - out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32; - out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64; - out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16; - out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32; - out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64; - out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools; - out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative; - out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative; - out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative; - out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative; - out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative; - out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind; - out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod; - out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers; - out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers; - out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers; - out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages; - out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages; - out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments; - out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources; - out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers; - out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers; - out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers; - out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages; - out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages; - out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments; - out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes; - out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes; - out_ext->independentResolveNone = in_ext->independentResolveNone; - out_ext->independentResolve = in_ext->independentResolve; - out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats; - out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping; - out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference; - out_ext->framebufferIntegerColorSampleCounts = in_ext->framebufferIntegerColorSampleCounts; + VkPhysicalDeviceRayTracingPipelinePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR); + const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *in_ext = (const VkPhysicalDeviceRayTracingPipelinePropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR; + out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize; + out_ext->maxRayRecursionDepth = in_ext->maxRayRecursionDepth; + out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride; + out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment; + out_ext->shaderGroupHandleCaptureReplaySize = in_ext->shaderGroupHandleCaptureReplaySize; + out_ext->maxRayDispatchInvocationCount = in_ext->maxRayDispatchInvocationCount; + out_ext->shaderGroupHandleAlignment = in_ext->shaderGroupHandleAlignment; + out_ext->maxRayHitAttributeSize = in_ext->maxRayHitAttributeSize; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: { - VkPhysicalDeviceVulkan13Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES); - const VkPhysicalDeviceVulkan13Properties *in_ext = (const VkPhysicalDeviceVulkan13Properties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES; - out_ext->minSubgroupSize = in_ext->minSubgroupSize; - out_ext->maxSubgroupSize = in_ext->maxSubgroupSize; - out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups; - out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages; - out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize; - out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks; - out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; - out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks; - out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks; - out_ext->maxInlineUniformTotalSize = in_ext->maxInlineUniformTotalSize; - out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated; - out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated; - out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated; - out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated; - out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated; - out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated; - out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated; - out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated; - out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated; - out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated; - out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated; - out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated; - out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated; - out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated; - out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated; - out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; - out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated; - out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; - out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; - out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; - out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; - out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; - out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated; - out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; - out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; - out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated; - out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; - out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; - out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated; - out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; - out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes; - out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment; - out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes; - out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment; - out_ext->maxBufferSize = in_ext->maxBufferSize; + VkPhysicalDeviceRayTracingPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV); + const VkPhysicalDeviceRayTracingPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingPropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV; + out_ext->shaderGroupHandleSize = in_ext->shaderGroupHandleSize; + out_ext->maxRecursionDepth = in_ext->maxRecursionDepth; + out_ext->maxShaderGroupStride = in_ext->maxShaderGroupStride; + out_ext->shaderGroupBaseAlignment = in_ext->shaderGroupBaseAlignment; + out_ext->maxGeometryCount = in_ext->maxGeometryCount; + out_ext->maxInstanceCount = in_ext->maxInstanceCount; + out_ext->maxTriangleCount = in_ext->maxTriangleCount; + out_ext->maxDescriptorSetAccelerationStructures = in_ext->maxDescriptorSetAccelerationStructures; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: { - VkPhysicalDeviceVulkan14Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES); - const VkPhysicalDeviceVulkan14Properties *in_ext = (const VkPhysicalDeviceVulkan14Properties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES; - out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits; - out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor; - out_ext->supportsNonZeroFirstInstance = in_ext->supportsNonZeroFirstInstance; - out_ext->maxPushDescriptors = in_ext->maxPushDescriptors; - out_ext->dynamicRenderingLocalReadDepthStencilAttachments = in_ext->dynamicRenderingLocalReadDepthStencilAttachments; - out_ext->dynamicRenderingLocalReadMultisampledAttachments = in_ext->dynamicRenderingLocalReadMultisampledAttachments; - out_ext->earlyFragmentMultisampleCoverageAfterSampleCounting = in_ext->earlyFragmentMultisampleCoverageAfterSampleCounting; - out_ext->earlyFragmentSampleMaskTestBeforeSampleCounting = in_ext->earlyFragmentSampleMaskTestBeforeSampleCounting; - out_ext->depthStencilSwizzleOneSupport = in_ext->depthStencilSwizzleOneSupport; - out_ext->polygonModePointSize = in_ext->polygonModePointSize; - out_ext->nonStrictSinglePixelWideLinesUseParallelogram = in_ext->nonStrictSinglePixelWideLinesUseParallelogram; - out_ext->nonStrictWideLinesUseParallelogram = in_ext->nonStrictWideLinesUseParallelogram; - out_ext->blockTexelViewCompatibleMultipleLayers = in_ext->blockTexelViewCompatibleMultipleLayers; - out_ext->maxCombinedImageSamplerDescriptorCount = in_ext->maxCombinedImageSamplerDescriptorCount; - out_ext->fragmentShadingRateClampCombinerInputs = in_ext->fragmentShadingRateClampCombinerInputs; - out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers; - out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers; - out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs; - out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages; - out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount; - out_ext->pCopySrcLayouts = PtrToUlong(in_ext->pCopySrcLayouts); - out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount; - out_ext->pCopyDstLayouts = PtrToUlong(in_ext->pCopyDstLayouts); - memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t)); - out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: - { - VkPhysicalDeviceCustomBorderColorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT); - const VkPhysicalDeviceCustomBorderColorPropertiesEXT *in_ext = (const VkPhysicalDeviceCustomBorderColorPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT; - out_ext->maxCustomBorderColorSamplers = in_ext->maxCustomBorderColorSamplers; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: - { - VkPhysicalDeviceExtendedDynamicState3PropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT); - const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *in_ext = (const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT; - out_ext->dynamicPrimitiveTopologyUnrestricted = in_ext->dynamicPrimitiveTopologyUnrestricted; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV: - { - VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV); - const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *in_ext = (const VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV; - out_ext->maxPartitionCount = in_ext->maxPartitionCount; + VkPhysicalDeviceRenderPassStripedPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM); + const VkPhysicalDeviceRenderPassStripedPropertiesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedPropertiesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM; + out_ext->renderPassStripeGranularity = in_ext->renderPassStripeGranularity; + out_ext->maxRenderPassStripes = in_ext->maxRenderPassStripes; out_header = (void *)out_ext; break; } @@ -36197,140 +36210,89 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: - { - VkPhysicalDeviceFragmentShadingRatePropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR); - const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShadingRatePropertiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR; - out_ext->minFragmentShadingRateAttachmentTexelSize = in_ext->minFragmentShadingRateAttachmentTexelSize; - out_ext->maxFragmentShadingRateAttachmentTexelSize = in_ext->maxFragmentShadingRateAttachmentTexelSize; - out_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio = in_ext->maxFragmentShadingRateAttachmentTexelSizeAspectRatio; - out_ext->primitiveFragmentShadingRateWithMultipleViewports = in_ext->primitiveFragmentShadingRateWithMultipleViewports; - out_ext->layeredShadingRateAttachments = in_ext->layeredShadingRateAttachments; - out_ext->fragmentShadingRateNonTrivialCombinerOps = in_ext->fragmentShadingRateNonTrivialCombinerOps; - out_ext->maxFragmentSize = in_ext->maxFragmentSize; - out_ext->maxFragmentSizeAspectRatio = in_ext->maxFragmentSizeAspectRatio; - out_ext->maxFragmentShadingRateCoverageSamples = in_ext->maxFragmentShadingRateCoverageSamples; - out_ext->maxFragmentShadingRateRasterizationSamples = in_ext->maxFragmentShadingRateRasterizationSamples; - out_ext->fragmentShadingRateWithShaderDepthStencilWrites = in_ext->fragmentShadingRateWithShaderDepthStencilWrites; - out_ext->fragmentShadingRateWithSampleMask = in_ext->fragmentShadingRateWithSampleMask; - out_ext->fragmentShadingRateWithShaderSampleMask = in_ext->fragmentShadingRateWithShaderSampleMask; - out_ext->fragmentShadingRateWithConservativeRasterization = in_ext->fragmentShadingRateWithConservativeRasterization; - out_ext->fragmentShadingRateWithFragmentShaderInterlock = in_ext->fragmentShadingRateWithFragmentShaderInterlock; - out_ext->fragmentShadingRateWithCustomSampleLocations = in_ext->fragmentShadingRateWithCustomSampleLocations; - out_ext->fragmentShadingRateStrictMultiplyCombiner = in_ext->fragmentShadingRateStrictMultiplyCombiner; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: { - VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV); - const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *in_ext = (const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV; - out_ext->maxFragmentShadingRateInvocationCount = in_ext->maxFragmentShadingRateInvocationCount; + VkPhysicalDeviceSampleLocationsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT); + const VkPhysicalDeviceSampleLocationsPropertiesEXT *in_ext = (const VkPhysicalDeviceSampleLocationsPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT; + out_ext->sampleLocationSampleCounts = in_ext->sampleLocationSampleCounts; + out_ext->maxSampleLocationGridSize = in_ext->maxSampleLocationGridSize; + memcpy(out_ext->sampleLocationCoordinateRange, in_ext->sampleLocationCoordinateRange, 2 * sizeof(float)); + out_ext->sampleLocationSubPixelBits = in_ext->sampleLocationSubPixelBits; + out_ext->variableSampleLocations = in_ext->variableSampleLocations; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: { - VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT); - const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *in_ext = (const VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT; - out_ext->nativeUnalignedPerformance = in_ext->nativeUnalignedPerformance; + VkPhysicalDeviceSamplerFilterMinmaxProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES); + const VkPhysicalDeviceSamplerFilterMinmaxProperties *in_ext = (const VkPhysicalDeviceSamplerFilterMinmaxProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES; + out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats; + out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: { - VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT); - const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *in_ext = (const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT; - out_ext->maxIndirectPipelineCount = in_ext->maxIndirectPipelineCount; - out_ext->maxIndirectShaderObjectCount = in_ext->maxIndirectShaderObjectCount; - out_ext->maxIndirectSequenceCount = in_ext->maxIndirectSequenceCount; - out_ext->maxIndirectCommandsTokenCount = in_ext->maxIndirectCommandsTokenCount; - out_ext->maxIndirectCommandsTokenOffset = in_ext->maxIndirectCommandsTokenOffset; - out_ext->maxIndirectCommandsIndirectStride = in_ext->maxIndirectCommandsIndirectStride; - out_ext->supportedIndirectCommandsInputModes = in_ext->supportedIndirectCommandsInputModes; - out_ext->supportedIndirectCommandsShaderStages = in_ext->supportedIndirectCommandsShaderStages; - out_ext->supportedIndirectCommandsShaderStagesPipelineBinding = in_ext->supportedIndirectCommandsShaderStagesPipelineBinding; - out_ext->supportedIndirectCommandsShaderStagesShaderBinding = in_ext->supportedIndirectCommandsShaderStagesShaderBinding; - out_ext->deviceGeneratedCommandsTransformFeedback = in_ext->deviceGeneratedCommandsTransformFeedback; - out_ext->deviceGeneratedCommandsMultiDrawIndirectCount = in_ext->deviceGeneratedCommandsMultiDrawIndirectCount; + VkPhysicalDeviceSchedulingControlsPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM); + const VkPhysicalDeviceSchedulingControlsPropertiesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsPropertiesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM; + out_ext->schedulingControlsFlags = in_ext->schedulingControlsFlags; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: { - VkPhysicalDeviceHostImageCopyProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES); - const VkPhysicalDeviceHostImageCopyProperties *in_ext = (const VkPhysicalDeviceHostImageCopyProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES; - out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount; - out_ext->pCopySrcLayouts = PtrToUlong(in_ext->pCopySrcLayouts); - out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount; - out_ext->pCopyDstLayouts = PtrToUlong(in_ext->pCopyDstLayouts); - memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t)); - out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements; + VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM); + const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; + out_ext->shaderCoreMask = in_ext->shaderCoreMask; + out_ext->shaderCoreCount = in_ext->shaderCoreCount; + out_ext->shaderWarpsPerCore = in_ext->shaderWarpsPerCore; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: { - VkPhysicalDeviceProvokingVertexPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT); - const VkPhysicalDeviceProvokingVertexPropertiesEXT *in_ext = (const VkPhysicalDeviceProvokingVertexPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT; - out_ext->provokingVertexModePerPipeline = in_ext->provokingVertexModePerPipeline; - out_ext->transformFeedbackPreservesTriangleFanProvokingVertex = in_ext->transformFeedbackPreservesTriangleFanProvokingVertex; + VkPhysicalDeviceShaderCoreProperties2AMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD); + const VkPhysicalDeviceShaderCoreProperties2AMD *in_ext = (const VkPhysicalDeviceShaderCoreProperties2AMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD; + out_ext->shaderCoreFeatures = in_ext->shaderCoreFeatures; + out_ext->activeComputeUnitCount = in_ext->activeComputeUnitCount; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: { - VkPhysicalDeviceDescriptorBufferPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT); - const VkPhysicalDeviceDescriptorBufferPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT; - out_ext->combinedImageSamplerDescriptorSingleArray = in_ext->combinedImageSamplerDescriptorSingleArray; - out_ext->bufferlessPushDescriptors = in_ext->bufferlessPushDescriptors; - out_ext->allowSamplerImageViewPostSubmitCreation = in_ext->allowSamplerImageViewPostSubmitCreation; - out_ext->descriptorBufferOffsetAlignment = in_ext->descriptorBufferOffsetAlignment; - out_ext->maxDescriptorBufferBindings = in_ext->maxDescriptorBufferBindings; - out_ext->maxResourceDescriptorBufferBindings = in_ext->maxResourceDescriptorBufferBindings; - out_ext->maxSamplerDescriptorBufferBindings = in_ext->maxSamplerDescriptorBufferBindings; - out_ext->maxEmbeddedImmutableSamplerBindings = in_ext->maxEmbeddedImmutableSamplerBindings; - out_ext->maxEmbeddedImmutableSamplers = in_ext->maxEmbeddedImmutableSamplers; - out_ext->bufferCaptureReplayDescriptorDataSize = in_ext->bufferCaptureReplayDescriptorDataSize; - out_ext->imageCaptureReplayDescriptorDataSize = in_ext->imageCaptureReplayDescriptorDataSize; - out_ext->imageViewCaptureReplayDescriptorDataSize = in_ext->imageViewCaptureReplayDescriptorDataSize; - out_ext->samplerCaptureReplayDescriptorDataSize = in_ext->samplerCaptureReplayDescriptorDataSize; - out_ext->accelerationStructureCaptureReplayDescriptorDataSize = in_ext->accelerationStructureCaptureReplayDescriptorDataSize; - out_ext->samplerDescriptorSize = in_ext->samplerDescriptorSize; - out_ext->combinedImageSamplerDescriptorSize = in_ext->combinedImageSamplerDescriptorSize; - out_ext->sampledImageDescriptorSize = in_ext->sampledImageDescriptorSize; - out_ext->storageImageDescriptorSize = in_ext->storageImageDescriptorSize; - out_ext->uniformTexelBufferDescriptorSize = in_ext->uniformTexelBufferDescriptorSize; - out_ext->robustUniformTexelBufferDescriptorSize = in_ext->robustUniformTexelBufferDescriptorSize; - out_ext->storageTexelBufferDescriptorSize = in_ext->storageTexelBufferDescriptorSize; - out_ext->robustStorageTexelBufferDescriptorSize = in_ext->robustStorageTexelBufferDescriptorSize; - out_ext->uniformBufferDescriptorSize = in_ext->uniformBufferDescriptorSize; - out_ext->robustUniformBufferDescriptorSize = in_ext->robustUniformBufferDescriptorSize; - out_ext->storageBufferDescriptorSize = in_ext->storageBufferDescriptorSize; - out_ext->robustStorageBufferDescriptorSize = in_ext->robustStorageBufferDescriptorSize; - out_ext->inputAttachmentDescriptorSize = in_ext->inputAttachmentDescriptorSize; - out_ext->accelerationStructureDescriptorSize = in_ext->accelerationStructureDescriptorSize; - out_ext->maxSamplerDescriptorBufferRange = in_ext->maxSamplerDescriptorBufferRange; - out_ext->maxResourceDescriptorBufferRange = in_ext->maxResourceDescriptorBufferRange; - out_ext->samplerDescriptorBufferAddressSpaceSize = in_ext->samplerDescriptorBufferAddressSpaceSize; - out_ext->resourceDescriptorBufferAddressSpaceSize = in_ext->resourceDescriptorBufferAddressSpaceSize; - out_ext->descriptorBufferAddressSpaceSize = in_ext->descriptorBufferAddressSpaceSize; + VkPhysicalDeviceShaderCorePropertiesAMD32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD); + const VkPhysicalDeviceShaderCorePropertiesAMD *in_ext = (const VkPhysicalDeviceShaderCorePropertiesAMD *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD; + out_ext->shaderEngineCount = in_ext->shaderEngineCount; + out_ext->shaderArraysPerEngineCount = in_ext->shaderArraysPerEngineCount; + out_ext->computeUnitsPerShaderArray = in_ext->computeUnitsPerShaderArray; + out_ext->simdPerComputeUnit = in_ext->simdPerComputeUnit; + out_ext->wavefrontsPerSimd = in_ext->wavefrontsPerSimd; + out_ext->wavefrontSize = in_ext->wavefrontSize; + out_ext->sgprsPerSimd = in_ext->sgprsPerSimd; + out_ext->minSgprAllocation = in_ext->minSgprAllocation; + out_ext->maxSgprAllocation = in_ext->maxSgprAllocation; + out_ext->sgprAllocationGranularity = in_ext->sgprAllocationGranularity; + out_ext->vgprsPerSimd = in_ext->vgprsPerSimd; + out_ext->minVgprAllocation = in_ext->minVgprAllocation; + out_ext->maxVgprAllocation = in_ext->maxVgprAllocation; + out_ext->vgprAllocationGranularity = in_ext->vgprAllocationGranularity; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: { - VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT); - const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *in_ext = (const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT; - out_ext->combinedImageSamplerDensityMapDescriptorSize = in_ext->combinedImageSamplerDensityMapDescriptorSize; + VkPhysicalDeviceShaderCorePropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM); + const VkPhysicalDeviceShaderCorePropertiesARM *in_ext = (const VkPhysicalDeviceShaderCorePropertiesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM; + out_ext->pixelRate = in_ext->pixelRate; + out_ext->texelRate = in_ext->texelRate; + out_ext->fmaRate = in_ext->fmaRate; out_header = (void *)out_ext; break; } @@ -36372,178 +36334,120 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: { - VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR); - const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *in_ext = (const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR; - out_ext->triStripVertexOrderIndependentOfProvokingVertex = in_ext->triStripVertexOrderIndependentOfProvokingVertex; + VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT); + const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; + memcpy(out_ext->shaderModuleIdentifierAlgorithmUUID, in_ext->shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE * sizeof(uint8_t)); out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: { - VkPhysicalDevicePipelineBinaryPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR); - const VkPhysicalDevicePipelineBinaryPropertiesKHR *in_ext = (const VkPhysicalDevicePipelineBinaryPropertiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR; - out_ext->pipelineBinaryInternalCache = in_ext->pipelineBinaryInternalCache; - out_ext->pipelineBinaryInternalCacheControl = in_ext->pipelineBinaryInternalCacheControl; - out_ext->pipelineBinaryPrefersInternalCache = in_ext->pipelineBinaryPrefersInternalCache; - out_ext->pipelineBinaryPrecompiledInternalCache = in_ext->pipelineBinaryPrecompiledInternalCache; - out_ext->pipelineBinaryCompressedData = in_ext->pipelineBinaryCompressedData; + VkPhysicalDeviceShaderObjectPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT); + const VkPhysicalDeviceShaderObjectPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderObjectPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; + memcpy(out_ext->shaderBinaryUUID, in_ext->shaderBinaryUUID, VK_UUID_SIZE * sizeof(uint8_t)); + out_ext->shaderBinaryVersion = in_ext->shaderBinaryVersion; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: { - VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT); - const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *in_ext = (const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT; - out_ext->graphicsPipelineLibraryFastLinking = in_ext->graphicsPipelineLibraryFastLinking; - out_ext->graphicsPipelineLibraryIndependentInterpolationDecoration = in_ext->graphicsPipelineLibraryIndependentInterpolationDecoration; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: - { - VkPhysicalDeviceNestedCommandBufferPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT); - const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *in_ext = (const VkPhysicalDeviceNestedCommandBufferPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT; - out_ext->maxCommandBufferNestingLevel = in_ext->maxCommandBufferNestingLevel; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: - { - VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT); - const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT; - memcpy(out_ext->shaderModuleIdentifierAlgorithmUUID, in_ext->shaderModuleIdentifierAlgorithmUUID, VK_UUID_SIZE * sizeof(uint8_t)); - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: - { - VkPhysicalDeviceOpacityMicromapPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT); - const VkPhysicalDeviceOpacityMicromapPropertiesEXT *in_ext = (const VkPhysicalDeviceOpacityMicromapPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT; - out_ext->maxOpacity2StateSubdivisionLevel = in_ext->maxOpacity2StateSubdivisionLevel; - out_ext->maxOpacity4StateSubdivisionLevel = in_ext->maxOpacity4StateSubdivisionLevel; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: - { - VkPhysicalDevicePipelineRobustnessProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES); - const VkPhysicalDevicePipelineRobustnessProperties *in_ext = (const VkPhysicalDevicePipelineRobustnessProperties *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES; - out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers; - out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers; - out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs; - out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: - { - VkPhysicalDeviceImageProcessingPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM); - const VkPhysicalDeviceImageProcessingPropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessingPropertiesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM; - out_ext->maxWeightFilterPhases = in_ext->maxWeightFilterPhases; - out_ext->maxWeightFilterDimension = in_ext->maxWeightFilterDimension; - out_ext->maxBlockMatchRegion = in_ext->maxBlockMatchRegion; - out_ext->maxBoxFilterBlockSize = in_ext->maxBoxFilterBlockSize; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: - { - VkPhysicalDeviceOpticalFlowPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV); - const VkPhysicalDeviceOpticalFlowPropertiesNV *in_ext = (const VkPhysicalDeviceOpticalFlowPropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV; - out_ext->supportedOutputGridSizes = in_ext->supportedOutputGridSizes; - out_ext->supportedHintGridSizes = in_ext->supportedHintGridSizes; - out_ext->hintSupported = in_ext->hintSupported; - out_ext->costSupported = in_ext->costSupported; - out_ext->bidirectionalFlowSupported = in_ext->bidirectionalFlowSupported; - out_ext->globalFlowSupported = in_ext->globalFlowSupported; - out_ext->minWidth = in_ext->minWidth; - out_ext->minHeight = in_ext->minHeight; - out_ext->maxWidth = in_ext->maxWidth; - out_ext->maxHeight = in_ext->maxHeight; - out_ext->maxNumRegionsOfInterest = in_ext->maxNumRegionsOfInterest; + VkPhysicalDeviceShaderSMBuiltinsPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV); + const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *in_ext = (const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV; + out_ext->shaderSMCount = in_ext->shaderSMCount; + out_ext->shaderWarpsPerSM = in_ext->shaderWarpsPerSM; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: { - VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM); - const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *in_ext = (const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM; - out_ext->shaderCoreMask = in_ext->shaderCoreMask; - out_ext->shaderCoreCount = in_ext->shaderCoreCount; - out_ext->shaderWarpsPerCore = in_ext->shaderWarpsPerCore; + VkPhysicalDeviceShaderTileImagePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT); + const VkPhysicalDeviceShaderTileImagePropertiesEXT *in_ext = (const VkPhysicalDeviceShaderTileImagePropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT; + out_ext->shaderTileImageCoherentReadAccelerated = in_ext->shaderTileImageCoherentReadAccelerated; + out_ext->shaderTileImageReadSampleFromPixelRateInvocation = in_ext->shaderTileImageReadSampleFromPixelRateInvocation; + out_ext->shaderTileImageReadFromHelperInvocation = in_ext->shaderTileImageReadFromHelperInvocation; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: { - VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV); - const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *in_ext = (const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV; - out_ext->rayTracingInvocationReorderReorderingHint = in_ext->rayTracingInvocationReorderReorderingHint; + VkPhysicalDeviceShadingRateImagePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV); + const VkPhysicalDeviceShadingRateImagePropertiesNV *in_ext = (const VkPhysicalDeviceShadingRateImagePropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV; + out_ext->shadingRateTexelSize = in_ext->shadingRateTexelSize; + out_ext->shadingRatePaletteSize = in_ext->shadingRatePaletteSize; + out_ext->shadingRateMaxCoarseSamples = in_ext->shadingRateMaxCoarseSamples; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: { - VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV); - const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *in_ext = (const VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV; - out_ext->extendedSparseAddressSpaceSize = in_ext->extendedSparseAddressSpaceSize; - out_ext->extendedSparseImageUsageFlags = in_ext->extendedSparseImageUsageFlags; - out_ext->extendedSparseBufferUsageFlags = in_ext->extendedSparseBufferUsageFlags; + VkPhysicalDeviceSubgroupProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES); + const VkPhysicalDeviceSubgroupProperties *in_ext = (const VkPhysicalDeviceSubgroupProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES; + out_ext->subgroupSize = in_ext->subgroupSize; + out_ext->supportedStages = in_ext->supportedStages; + out_ext->supportedOperations = in_ext->supportedOperations; + out_ext->quadOperationsInAllStages = in_ext->quadOperationsInAllStages; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: { - VkPhysicalDeviceShaderCorePropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM); - const VkPhysicalDeviceShaderCorePropertiesARM *in_ext = (const VkPhysicalDeviceShaderCorePropertiesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM; - out_ext->pixelRate = in_ext->pixelRate; - out_ext->texelRate = in_ext->texelRate; - out_ext->fmaRate = in_ext->fmaRate; + VkPhysicalDeviceSubgroupSizeControlProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES); + const VkPhysicalDeviceSubgroupSizeControlProperties *in_ext = (const VkPhysicalDeviceSubgroupSizeControlProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES; + out_ext->minSubgroupSize = in_ext->minSubgroupSize; + out_ext->maxSubgroupSize = in_ext->maxSubgroupSize; + out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups; + out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: { - VkPhysicalDeviceShaderObjectPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT); - const VkPhysicalDeviceShaderObjectPropertiesEXT *in_ext = (const VkPhysicalDeviceShaderObjectPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT; - memcpy(out_ext->shaderBinaryUUID, in_ext->shaderBinaryUUID, VK_UUID_SIZE * sizeof(uint8_t)); - out_ext->shaderBinaryVersion = in_ext->shaderBinaryVersion; + VkPhysicalDeviceSubpassShadingPropertiesHUAWEI32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI); + const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *in_ext = (const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI; + out_ext->maxSubpassShadingWorkgroupSizeAspectRatio = in_ext->maxSubpassShadingWorkgroupSizeAspectRatio; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: { - VkPhysicalDeviceShaderTileImagePropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT); - const VkPhysicalDeviceShaderTileImagePropertiesEXT *in_ext = (const VkPhysicalDeviceShaderTileImagePropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT; - out_ext->shaderTileImageCoherentReadAccelerated = in_ext->shaderTileImageCoherentReadAccelerated; - out_ext->shaderTileImageReadSampleFromPixelRateInvocation = in_ext->shaderTileImageReadSampleFromPixelRateInvocation; - out_ext->shaderTileImageReadFromHelperInvocation = in_ext->shaderTileImageReadFromHelperInvocation; + VkPhysicalDeviceTensorPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM); + const VkPhysicalDeviceTensorPropertiesARM *in_ext = (const VkPhysicalDeviceTensorPropertiesARM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; + out_ext->maxTensorDimensionCount = in_ext->maxTensorDimensionCount; + out_ext->maxTensorElements = in_ext->maxTensorElements; + out_ext->maxPerDimensionTensorElements = in_ext->maxPerDimensionTensorElements; + out_ext->maxTensorStride = in_ext->maxTensorStride; + out_ext->maxTensorSize = in_ext->maxTensorSize; + out_ext->maxTensorShaderAccessArrayLength = in_ext->maxTensorShaderAccessArrayLength; + out_ext->maxTensorShaderAccessSize = in_ext->maxTensorShaderAccessSize; + out_ext->maxDescriptorSetStorageTensors = in_ext->maxDescriptorSetStorageTensors; + out_ext->maxPerStageDescriptorSetStorageTensors = in_ext->maxPerStageDescriptorSetStorageTensors; + out_ext->maxDescriptorSetUpdateAfterBindStorageTensors = in_ext->maxDescriptorSetUpdateAfterBindStorageTensors; + out_ext->maxPerStageDescriptorUpdateAfterBindStorageTensors = in_ext->maxPerStageDescriptorUpdateAfterBindStorageTensors; + out_ext->shaderStorageTensorArrayNonUniformIndexingNative = in_ext->shaderStorageTensorArrayNonUniformIndexingNative; + out_ext->shaderTensorSupportedStages = in_ext->shaderTensorSupportedStages; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: { - VkPhysicalDeviceCooperativeMatrixPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR); - const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *in_ext = (const VkPhysicalDeviceCooperativeMatrixPropertiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR; - out_ext->cooperativeMatrixSupportedStages = in_ext->cooperativeMatrixSupportedStages; + VkPhysicalDeviceTexelBufferAlignmentProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES); + const VkPhysicalDeviceTexelBufferAlignmentProperties *in_ext = (const VkPhysicalDeviceTexelBufferAlignmentProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES; + out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes; + out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment; + out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes; + out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment; out_header = (void *)out_ext; break; } @@ -36557,134 +36461,230 @@ static void convert_VkPhysicalDeviceProperties2_host_to_win32(const VkPhysicalDe out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: - { - VkPhysicalDeviceImageProcessing2PropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM); - const VkPhysicalDeviceImageProcessing2PropertiesQCOM *in_ext = (const VkPhysicalDeviceImageProcessing2PropertiesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM; - out_ext->maxBlockMatchWindow = in_ext->maxBlockMatchWindow; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: - { - VkPhysicalDeviceLayeredDriverPropertiesMSFT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT); - const VkPhysicalDeviceLayeredDriverPropertiesMSFT *in_ext = (const VkPhysicalDeviceLayeredDriverPropertiesMSFT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT; - out_ext->underlyingAPI = in_ext->underlyingAPI; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: - { - VkPhysicalDeviceSchedulingControlsPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM); - const VkPhysicalDeviceSchedulingControlsPropertiesARM *in_ext = (const VkPhysicalDeviceSchedulingControlsPropertiesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM; - out_ext->schedulingControlsFlags = in_ext->schedulingControlsFlags; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: { - VkPhysicalDeviceRenderPassStripedPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM); - const VkPhysicalDeviceRenderPassStripedPropertiesARM *in_ext = (const VkPhysicalDeviceRenderPassStripedPropertiesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM; - out_ext->renderPassStripeGranularity = in_ext->renderPassStripeGranularity; - out_ext->maxRenderPassStripes = in_ext->maxRenderPassStripes; + VkPhysicalDeviceTileShadingPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM); + const VkPhysicalDeviceTileShadingPropertiesQCOM *in_ext = (const VkPhysicalDeviceTileShadingPropertiesQCOM *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM; + out_ext->maxApronSize = in_ext->maxApronSize; + out_ext->preferNonCoherent = in_ext->preferNonCoherent; + out_ext->tileGranularity = in_ext->tileGranularity; + out_ext->maxTileShadingRate = in_ext->maxTileShadingRate; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: { - VkPhysicalDeviceMapMemoryPlacedPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT); - const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *in_ext = (const VkPhysicalDeviceMapMemoryPlacedPropertiesEXT *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT; - out_ext->minPlacedMemoryMapAlignment = in_ext->minPlacedMemoryMapAlignment; + VkPhysicalDeviceTimelineSemaphoreProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES); + const VkPhysicalDeviceTimelineSemaphoreProperties *in_ext = (const VkPhysicalDeviceTimelineSemaphoreProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES; + out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: { - VkPhysicalDeviceImageAlignmentControlPropertiesMESA32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA); - const VkPhysicalDeviceImageAlignmentControlPropertiesMESA *in_ext = (const VkPhysicalDeviceImageAlignmentControlPropertiesMESA *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA; - out_ext->supportedImageAlignmentMask = in_ext->supportedImageAlignmentMask; + VkPhysicalDeviceTransformFeedbackPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT); + const VkPhysicalDeviceTransformFeedbackPropertiesEXT *in_ext = (const VkPhysicalDeviceTransformFeedbackPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; + out_ext->maxTransformFeedbackStreams = in_ext->maxTransformFeedbackStreams; + out_ext->maxTransformFeedbackBuffers = in_ext->maxTransformFeedbackBuffers; + out_ext->maxTransformFeedbackBufferSize = in_ext->maxTransformFeedbackBufferSize; + out_ext->maxTransformFeedbackStreamDataSize = in_ext->maxTransformFeedbackStreamDataSize; + out_ext->maxTransformFeedbackBufferDataSize = in_ext->maxTransformFeedbackBufferDataSize; + out_ext->maxTransformFeedbackBufferDataStride = in_ext->maxTransformFeedbackBufferDataStride; + out_ext->transformFeedbackQueries = in_ext->transformFeedbackQueries; + out_ext->transformFeedbackStreamsLinesTriangles = in_ext->transformFeedbackStreamsLinesTriangles; + out_ext->transformFeedbackRasterizationStreamSelect = in_ext->transformFeedbackRasterizationStreamSelect; + out_ext->transformFeedbackDraw = in_ext->transformFeedbackDraw; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: { - VkPhysicalDeviceCooperativeMatrix2PropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV); - const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeMatrix2PropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV; - out_ext->cooperativeMatrixWorkgroupScopeMaxWorkgroupSize = in_ext->cooperativeMatrixWorkgroupScopeMaxWorkgroupSize; - out_ext->cooperativeMatrixFlexibleDimensionsMaxDimension = in_ext->cooperativeMatrixFlexibleDimensionsMaxDimension; - out_ext->cooperativeMatrixWorkgroupScopeReservedSharedMemory = in_ext->cooperativeMatrixWorkgroupScopeReservedSharedMemory; + VkPhysicalDeviceVertexAttributeDivisorProperties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES); + const VkPhysicalDeviceVertexAttributeDivisorProperties *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorProperties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES; + out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor; + out_ext->supportsNonZeroFirstInstance = in_ext->supportsNonZeroFirstInstance; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: { - VkPhysicalDeviceCooperativeVectorPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV); - const VkPhysicalDeviceCooperativeVectorPropertiesNV *in_ext = (const VkPhysicalDeviceCooperativeVectorPropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV; - out_ext->cooperativeVectorSupportedStages = in_ext->cooperativeVectorSupportedStages; - out_ext->cooperativeVectorTrainingFloat16Accumulation = in_ext->cooperativeVectorTrainingFloat16Accumulation; - out_ext->cooperativeVectorTrainingFloat32Accumulation = in_ext->cooperativeVectorTrainingFloat32Accumulation; - out_ext->maxCooperativeVectorComponents = in_ext->maxCooperativeVectorComponents; + VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT); + const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *in_ext = (const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; + out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: { - VkPhysicalDeviceTileShadingPropertiesQCOM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM); - const VkPhysicalDeviceTileShadingPropertiesQCOM *in_ext = (const VkPhysicalDeviceTileShadingPropertiesQCOM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM; - out_ext->maxApronSize = in_ext->maxApronSize; - out_ext->preferNonCoherent = in_ext->preferNonCoherent; - out_ext->tileGranularity = in_ext->tileGranularity; - out_ext->maxTileShadingRate = in_ext->maxTileShadingRate; + VkPhysicalDeviceVulkan11Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES); + const VkPhysicalDeviceVulkan11Properties *in_ext = (const VkPhysicalDeviceVulkan11Properties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES; + memcpy(out_ext->deviceUUID, in_ext->deviceUUID, VK_UUID_SIZE * sizeof(uint8_t)); + memcpy(out_ext->driverUUID, in_ext->driverUUID, VK_UUID_SIZE * sizeof(uint8_t)); + memcpy(out_ext->deviceLUID, in_ext->deviceLUID, VK_LUID_SIZE * sizeof(uint8_t)); + out_ext->deviceNodeMask = in_ext->deviceNodeMask; + out_ext->deviceLUIDValid = in_ext->deviceLUIDValid; + out_ext->subgroupSize = in_ext->subgroupSize; + out_ext->subgroupSupportedStages = in_ext->subgroupSupportedStages; + out_ext->subgroupSupportedOperations = in_ext->subgroupSupportedOperations; + out_ext->subgroupQuadOperationsInAllStages = in_ext->subgroupQuadOperationsInAllStages; + out_ext->pointClippingBehavior = in_ext->pointClippingBehavior; + out_ext->maxMultiviewViewCount = in_ext->maxMultiviewViewCount; + out_ext->maxMultiviewInstanceIndex = in_ext->maxMultiviewInstanceIndex; + out_ext->protectedNoFault = in_ext->protectedNoFault; + out_ext->maxPerSetDescriptors = in_ext->maxPerSetDescriptors; + out_ext->maxMemoryAllocationSize = in_ext->maxMemoryAllocationSize; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: { - VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE); - const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *in_ext = (const VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE; - out_ext->maxFragmentDensityMapLayers = in_ext->maxFragmentDensityMapLayers; + VkPhysicalDeviceVulkan12Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES); + const VkPhysicalDeviceVulkan12Properties *in_ext = (const VkPhysicalDeviceVulkan12Properties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES; + out_ext->driverID = in_ext->driverID; + memcpy(out_ext->driverName, in_ext->driverName, VK_MAX_DRIVER_NAME_SIZE * sizeof(char)); + memcpy(out_ext->driverInfo, in_ext->driverInfo, VK_MAX_DRIVER_INFO_SIZE * sizeof(char)); + out_ext->conformanceVersion = in_ext->conformanceVersion; + out_ext->denormBehaviorIndependence = in_ext->denormBehaviorIndependence; + out_ext->roundingModeIndependence = in_ext->roundingModeIndependence; + out_ext->shaderSignedZeroInfNanPreserveFloat16 = in_ext->shaderSignedZeroInfNanPreserveFloat16; + out_ext->shaderSignedZeroInfNanPreserveFloat32 = in_ext->shaderSignedZeroInfNanPreserveFloat32; + out_ext->shaderSignedZeroInfNanPreserveFloat64 = in_ext->shaderSignedZeroInfNanPreserveFloat64; + out_ext->shaderDenormPreserveFloat16 = in_ext->shaderDenormPreserveFloat16; + out_ext->shaderDenormPreserveFloat32 = in_ext->shaderDenormPreserveFloat32; + out_ext->shaderDenormPreserveFloat64 = in_ext->shaderDenormPreserveFloat64; + out_ext->shaderDenormFlushToZeroFloat16 = in_ext->shaderDenormFlushToZeroFloat16; + out_ext->shaderDenormFlushToZeroFloat32 = in_ext->shaderDenormFlushToZeroFloat32; + out_ext->shaderDenormFlushToZeroFloat64 = in_ext->shaderDenormFlushToZeroFloat64; + out_ext->shaderRoundingModeRTEFloat16 = in_ext->shaderRoundingModeRTEFloat16; + out_ext->shaderRoundingModeRTEFloat32 = in_ext->shaderRoundingModeRTEFloat32; + out_ext->shaderRoundingModeRTEFloat64 = in_ext->shaderRoundingModeRTEFloat64; + out_ext->shaderRoundingModeRTZFloat16 = in_ext->shaderRoundingModeRTZFloat16; + out_ext->shaderRoundingModeRTZFloat32 = in_ext->shaderRoundingModeRTZFloat32; + out_ext->shaderRoundingModeRTZFloat64 = in_ext->shaderRoundingModeRTZFloat64; + out_ext->maxUpdateAfterBindDescriptorsInAllPools = in_ext->maxUpdateAfterBindDescriptorsInAllPools; + out_ext->shaderUniformBufferArrayNonUniformIndexingNative = in_ext->shaderUniformBufferArrayNonUniformIndexingNative; + out_ext->shaderSampledImageArrayNonUniformIndexingNative = in_ext->shaderSampledImageArrayNonUniformIndexingNative; + out_ext->shaderStorageBufferArrayNonUniformIndexingNative = in_ext->shaderStorageBufferArrayNonUniformIndexingNative; + out_ext->shaderStorageImageArrayNonUniformIndexingNative = in_ext->shaderStorageImageArrayNonUniformIndexingNative; + out_ext->shaderInputAttachmentArrayNonUniformIndexingNative = in_ext->shaderInputAttachmentArrayNonUniformIndexingNative; + out_ext->robustBufferAccessUpdateAfterBind = in_ext->robustBufferAccessUpdateAfterBind; + out_ext->quadDivergentImplicitLod = in_ext->quadDivergentImplicitLod; + out_ext->maxPerStageDescriptorUpdateAfterBindSamplers = in_ext->maxPerStageDescriptorUpdateAfterBindSamplers; + out_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindUniformBuffers; + out_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers = in_ext->maxPerStageDescriptorUpdateAfterBindStorageBuffers; + out_ext->maxPerStageDescriptorUpdateAfterBindSampledImages = in_ext->maxPerStageDescriptorUpdateAfterBindSampledImages; + out_ext->maxPerStageDescriptorUpdateAfterBindStorageImages = in_ext->maxPerStageDescriptorUpdateAfterBindStorageImages; + out_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments = in_ext->maxPerStageDescriptorUpdateAfterBindInputAttachments; + out_ext->maxPerStageUpdateAfterBindResources = in_ext->maxPerStageUpdateAfterBindResources; + out_ext->maxDescriptorSetUpdateAfterBindSamplers = in_ext->maxDescriptorSetUpdateAfterBindSamplers; + out_ext->maxDescriptorSetUpdateAfterBindUniformBuffers = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffers; + out_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + out_ext->maxDescriptorSetUpdateAfterBindStorageBuffers = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffers; + out_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = in_ext->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + out_ext->maxDescriptorSetUpdateAfterBindSampledImages = in_ext->maxDescriptorSetUpdateAfterBindSampledImages; + out_ext->maxDescriptorSetUpdateAfterBindStorageImages = in_ext->maxDescriptorSetUpdateAfterBindStorageImages; + out_ext->maxDescriptorSetUpdateAfterBindInputAttachments = in_ext->maxDescriptorSetUpdateAfterBindInputAttachments; + out_ext->supportedDepthResolveModes = in_ext->supportedDepthResolveModes; + out_ext->supportedStencilResolveModes = in_ext->supportedStencilResolveModes; + out_ext->independentResolveNone = in_ext->independentResolveNone; + out_ext->independentResolve = in_ext->independentResolve; + out_ext->filterMinmaxSingleComponentFormats = in_ext->filterMinmaxSingleComponentFormats; + out_ext->filterMinmaxImageComponentMapping = in_ext->filterMinmaxImageComponentMapping; + out_ext->maxTimelineSemaphoreValueDifference = in_ext->maxTimelineSemaphoreValueDifference; + out_ext->framebufferIntegerColorSampleCounts = in_ext->framebufferIntegerColorSampleCounts; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: { - VkPhysicalDeviceTensorPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM); - const VkPhysicalDeviceTensorPropertiesARM *in_ext = (const VkPhysicalDeviceTensorPropertiesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM; - out_ext->maxTensorDimensionCount = in_ext->maxTensorDimensionCount; - out_ext->maxTensorElements = in_ext->maxTensorElements; - out_ext->maxPerDimensionTensorElements = in_ext->maxPerDimensionTensorElements; - out_ext->maxTensorStride = in_ext->maxTensorStride; - out_ext->maxTensorSize = in_ext->maxTensorSize; - out_ext->maxTensorShaderAccessArrayLength = in_ext->maxTensorShaderAccessArrayLength; - out_ext->maxTensorShaderAccessSize = in_ext->maxTensorShaderAccessSize; - out_ext->maxDescriptorSetStorageTensors = in_ext->maxDescriptorSetStorageTensors; - out_ext->maxPerStageDescriptorSetStorageTensors = in_ext->maxPerStageDescriptorSetStorageTensors; - out_ext->maxDescriptorSetUpdateAfterBindStorageTensors = in_ext->maxDescriptorSetUpdateAfterBindStorageTensors; - out_ext->maxPerStageDescriptorUpdateAfterBindStorageTensors = in_ext->maxPerStageDescriptorUpdateAfterBindStorageTensors; - out_ext->shaderStorageTensorArrayNonUniformIndexingNative = in_ext->shaderStorageTensorArrayNonUniformIndexingNative; - out_ext->shaderTensorSupportedStages = in_ext->shaderTensorSupportedStages; + VkPhysicalDeviceVulkan13Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES); + const VkPhysicalDeviceVulkan13Properties *in_ext = (const VkPhysicalDeviceVulkan13Properties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES; + out_ext->minSubgroupSize = in_ext->minSubgroupSize; + out_ext->maxSubgroupSize = in_ext->maxSubgroupSize; + out_ext->maxComputeWorkgroupSubgroups = in_ext->maxComputeWorkgroupSubgroups; + out_ext->requiredSubgroupSizeStages = in_ext->requiredSubgroupSizeStages; + out_ext->maxInlineUniformBlockSize = in_ext->maxInlineUniformBlockSize; + out_ext->maxPerStageDescriptorInlineUniformBlocks = in_ext->maxPerStageDescriptorInlineUniformBlocks; + out_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_ext->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + out_ext->maxDescriptorSetInlineUniformBlocks = in_ext->maxDescriptorSetInlineUniformBlocks; + out_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_ext->maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + out_ext->maxInlineUniformTotalSize = in_ext->maxInlineUniformTotalSize; + out_ext->integerDotProduct8BitUnsignedAccelerated = in_ext->integerDotProduct8BitUnsignedAccelerated; + out_ext->integerDotProduct8BitSignedAccelerated = in_ext->integerDotProduct8BitSignedAccelerated; + out_ext->integerDotProduct8BitMixedSignednessAccelerated = in_ext->integerDotProduct8BitMixedSignednessAccelerated; + out_ext->integerDotProduct4x8BitPackedUnsignedAccelerated = in_ext->integerDotProduct4x8BitPackedUnsignedAccelerated; + out_ext->integerDotProduct4x8BitPackedSignedAccelerated = in_ext->integerDotProduct4x8BitPackedSignedAccelerated; + out_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProduct4x8BitPackedMixedSignednessAccelerated; + out_ext->integerDotProduct16BitUnsignedAccelerated = in_ext->integerDotProduct16BitUnsignedAccelerated; + out_ext->integerDotProduct16BitSignedAccelerated = in_ext->integerDotProduct16BitSignedAccelerated; + out_ext->integerDotProduct16BitMixedSignednessAccelerated = in_ext->integerDotProduct16BitMixedSignednessAccelerated; + out_ext->integerDotProduct32BitUnsignedAccelerated = in_ext->integerDotProduct32BitUnsignedAccelerated; + out_ext->integerDotProduct32BitSignedAccelerated = in_ext->integerDotProduct32BitSignedAccelerated; + out_ext->integerDotProduct32BitMixedSignednessAccelerated = in_ext->integerDotProduct32BitMixedSignednessAccelerated; + out_ext->integerDotProduct64BitUnsignedAccelerated = in_ext->integerDotProduct64BitUnsignedAccelerated; + out_ext->integerDotProduct64BitSignedAccelerated = in_ext->integerDotProduct64BitSignedAccelerated; + out_ext->integerDotProduct64BitMixedSignednessAccelerated = in_ext->integerDotProduct64BitMixedSignednessAccelerated; + out_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + out_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitSignedAccelerated; + out_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + out_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + out_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + out_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + out_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + out_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitSignedAccelerated; + out_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + out_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + out_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitSignedAccelerated; + out_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + out_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + out_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitSignedAccelerated; + out_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated = in_ext->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + out_ext->storageTexelBufferOffsetAlignmentBytes = in_ext->storageTexelBufferOffsetAlignmentBytes; + out_ext->storageTexelBufferOffsetSingleTexelAlignment = in_ext->storageTexelBufferOffsetSingleTexelAlignment; + out_ext->uniformTexelBufferOffsetAlignmentBytes = in_ext->uniformTexelBufferOffsetAlignmentBytes; + out_ext->uniformTexelBufferOffsetSingleTexelAlignment = in_ext->uniformTexelBufferOffsetSingleTexelAlignment; + out_ext->maxBufferSize = in_ext->maxBufferSize; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: { - VkPhysicalDeviceDescriptorBufferTensorPropertiesARM32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM); - const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *in_ext = (const VkPhysicalDeviceDescriptorBufferTensorPropertiesARM *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM; - out_ext->tensorCaptureReplayDescriptorDataSize = in_ext->tensorCaptureReplayDescriptorDataSize; - out_ext->tensorViewCaptureReplayDescriptorDataSize = in_ext->tensorViewCaptureReplayDescriptorDataSize; - out_ext->tensorDescriptorSize = in_ext->tensorDescriptorSize; + VkPhysicalDeviceVulkan14Properties32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES); + const VkPhysicalDeviceVulkan14Properties *in_ext = (const VkPhysicalDeviceVulkan14Properties *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES; + out_ext->lineSubPixelPrecisionBits = in_ext->lineSubPixelPrecisionBits; + out_ext->maxVertexAttribDivisor = in_ext->maxVertexAttribDivisor; + out_ext->supportsNonZeroFirstInstance = in_ext->supportsNonZeroFirstInstance; + out_ext->maxPushDescriptors = in_ext->maxPushDescriptors; + out_ext->dynamicRenderingLocalReadDepthStencilAttachments = in_ext->dynamicRenderingLocalReadDepthStencilAttachments; + out_ext->dynamicRenderingLocalReadMultisampledAttachments = in_ext->dynamicRenderingLocalReadMultisampledAttachments; + out_ext->earlyFragmentMultisampleCoverageAfterSampleCounting = in_ext->earlyFragmentMultisampleCoverageAfterSampleCounting; + out_ext->earlyFragmentSampleMaskTestBeforeSampleCounting = in_ext->earlyFragmentSampleMaskTestBeforeSampleCounting; + out_ext->depthStencilSwizzleOneSupport = in_ext->depthStencilSwizzleOneSupport; + out_ext->polygonModePointSize = in_ext->polygonModePointSize; + out_ext->nonStrictSinglePixelWideLinesUseParallelogram = in_ext->nonStrictSinglePixelWideLinesUseParallelogram; + out_ext->nonStrictWideLinesUseParallelogram = in_ext->nonStrictWideLinesUseParallelogram; + out_ext->blockTexelViewCompatibleMultipleLayers = in_ext->blockTexelViewCompatibleMultipleLayers; + out_ext->maxCombinedImageSamplerDescriptorCount = in_ext->maxCombinedImageSamplerDescriptorCount; + out_ext->fragmentShadingRateClampCombinerInputs = in_ext->fragmentShadingRateClampCombinerInputs; + out_ext->defaultRobustnessStorageBuffers = in_ext->defaultRobustnessStorageBuffers; + out_ext->defaultRobustnessUniformBuffers = in_ext->defaultRobustnessUniformBuffers; + out_ext->defaultRobustnessVertexInputs = in_ext->defaultRobustnessVertexInputs; + out_ext->defaultRobustnessImages = in_ext->defaultRobustnessImages; + out_ext->copySrcLayoutCount = in_ext->copySrcLayoutCount; + out_ext->pCopySrcLayouts = PtrToUlong(in_ext->pCopySrcLayouts); + out_ext->copyDstLayoutCount = in_ext->copyDstLayoutCount; + out_ext->pCopyDstLayouts = PtrToUlong(in_ext->pCopyDstLayouts); + memcpy(out_ext->optimalTilingLayoutUUID, in_ext->optimalTilingLayoutUUID, VK_UUID_SIZE * sizeof(uint8_t)); + out_ext->identicalMemoryTypeRequirements = in_ext->identicalMemoryTypeRequirements; out_header = (void *)out_ext; break; } @@ -36801,19 +36801,10 @@ static void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_con { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: - { - VkQueueFamilyOwnershipTransferPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; - out_ext->pNext = NULL; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: { - VkQueueFamilyGlobalPriorityProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES; + VkQueueFamilyCheckpointProperties2NV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -36828,19 +36819,19 @@ static void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_con out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: { - VkQueueFamilyCheckpointProperties2NV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; + VkQueueFamilyGlobalPriorityProperties *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: { - VkQueueFamilyVideoPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR; + VkQueueFamilyOwnershipTransferPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -36855,6 +36846,15 @@ static void convert_VkQueueFamilyProperties2_win32_to_host(struct conversion_con out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: + { + VkQueueFamilyVideoPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -36891,12 +36891,21 @@ static void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyPr { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: { - VkQueueFamilyOwnershipTransferPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR); - const VkQueueFamilyOwnershipTransferPropertiesKHR *in_ext = (const VkQueueFamilyOwnershipTransferPropertiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; - out_ext->optimalImageTransferToQueueFamilies = in_ext->optimalImageTransferToQueueFamilies; + VkQueueFamilyCheckpointProperties2NV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV); + const VkQueueFamilyCheckpointProperties2NV *in_ext = (const VkQueueFamilyCheckpointProperties2NV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; + out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: + { + VkQueueFamilyCheckpointPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV); + const VkQueueFamilyCheckpointPropertiesNV *in_ext = (const VkQueueFamilyCheckpointPropertiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV; + out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask; out_header = (void *)out_ext; break; } @@ -36910,21 +36919,21 @@ static void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyPr out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: { - VkQueueFamilyCheckpointPropertiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV); - const VkQueueFamilyCheckpointPropertiesNV *in_ext = (const VkQueueFamilyCheckpointPropertiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV; - out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask; + VkQueueFamilyOwnershipTransferPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR); + const VkQueueFamilyOwnershipTransferPropertiesKHR *in_ext = (const VkQueueFamilyOwnershipTransferPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR; + out_ext->optimalImageTransferToQueueFamilies = in_ext->optimalImageTransferToQueueFamilies; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: { - VkQueueFamilyCheckpointProperties2NV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV); - const VkQueueFamilyCheckpointProperties2NV *in_ext = (const VkQueueFamilyCheckpointProperties2NV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV; - out_ext->checkpointExecutionStageMask = in_ext->checkpointExecutionStageMask; + VkQueueFamilyQueryResultStatusPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR); + const VkQueueFamilyQueryResultStatusPropertiesKHR *in_ext = (const VkQueueFamilyQueryResultStatusPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR; + out_ext->queryResultStatusSupport = in_ext->queryResultStatusSupport; out_header = (void *)out_ext; break; } @@ -36937,15 +36946,6 @@ static void convert_VkQueueFamilyProperties2_host_to_win32(const VkQueueFamilyPr out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: - { - VkQueueFamilyQueryResultStatusPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR); - const VkQueueFamilyQueryResultStatusPropertiesKHR *in_ext = (const VkQueueFamilyQueryResultStatusPropertiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR; - out_ext->queryResultStatusSupport = in_ext->queryResultStatusSupport; - out_header = (void *)out_ext; - break; - } default: break; } @@ -37119,6 +37119,18 @@ static void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_co { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: + { + VkLatencySurfaceCapabilitiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkLatencySurfaceCapabilitiesNV32 *in_ext = (const VkLatencySurfaceCapabilitiesNV32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV; + out_ext->pNext = NULL; + out_ext->presentModeCount = in_ext->presentModeCount; + out_ext->pPresentModes = UlongToPtr(in_ext->pPresentModes); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: { VkSurfaceCapabilitiesPresentBarrierNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -37150,21 +37162,6 @@ static void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: - { - VkSurfacePresentScalingCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkSurfacePresentScalingCapabilitiesKHR32 *in_ext = (const VkSurfacePresentScalingCapabilitiesKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR; - out_ext->pNext = NULL; - out_ext->supportedPresentScaling = in_ext->supportedPresentScaling; - out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX; - out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY; - out_ext->minScaledImageExtent = in_ext->minScaledImageExtent; - out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR: { VkSurfacePresentModeCompatibilityKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -37177,14 +37174,17 @@ static void convert_VkSurfaceCapabilities2KHR_win32_to_host(struct conversion_co out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: { - VkLatencySurfaceCapabilitiesNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkLatencySurfaceCapabilitiesNV32 *in_ext = (const VkLatencySurfaceCapabilitiesNV32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV; + VkSurfacePresentScalingCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkSurfacePresentScalingCapabilitiesKHR32 *in_ext = (const VkSurfacePresentScalingCapabilitiesKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR; out_ext->pNext = NULL; - out_ext->presentModeCount = in_ext->presentModeCount; - out_ext->pPresentModes = UlongToPtr(in_ext->pPresentModes); + out_ext->supportedPresentScaling = in_ext->supportedPresentScaling; + out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX; + out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY; + out_ext->minScaledImageExtent = in_ext->minScaledImageExtent; + out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -37209,6 +37209,16 @@ static void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapab { switch (in_header->sType) { + case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: + { + VkLatencySurfaceCapabilitiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV); + const VkLatencySurfaceCapabilitiesNV *in_ext = (const VkLatencySurfaceCapabilitiesNV *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV; + out_ext->presentModeCount = in_ext->presentModeCount; + out_ext->pPresentModes = PtrToUlong(in_ext->pPresentModes); + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: { VkSurfaceCapabilitiesPresentBarrierNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV); @@ -37236,19 +37246,6 @@ static void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapab out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: - { - VkSurfacePresentScalingCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR); - const VkSurfacePresentScalingCapabilitiesKHR *in_ext = (const VkSurfacePresentScalingCapabilitiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR; - out_ext->supportedPresentScaling = in_ext->supportedPresentScaling; - out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX; - out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY; - out_ext->minScaledImageExtent = in_ext->minScaledImageExtent; - out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR: { VkSurfacePresentModeCompatibilityKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR); @@ -37259,13 +37256,16 @@ static void convert_VkSurfaceCapabilities2KHR_host_to_win32(const VkSurfaceCapab out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: + case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: { - VkLatencySurfaceCapabilitiesNV32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV); - const VkLatencySurfaceCapabilitiesNV *in_ext = (const VkLatencySurfaceCapabilitiesNV *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV; - out_ext->presentModeCount = in_ext->presentModeCount; - out_ext->pPresentModes = PtrToUlong(in_ext->pPresentModes); + VkSurfacePresentScalingCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR); + const VkSurfacePresentScalingCapabilitiesKHR *in_ext = (const VkSurfacePresentScalingCapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR; + out_ext->supportedPresentScaling = in_ext->supportedPresentScaling; + out_ext->supportedPresentGravityX = in_ext->supportedPresentGravityX; + out_ext->supportedPresentGravityY = in_ext->supportedPresentGravityY; + out_ext->minScaledImageExtent = in_ext->minScaledImageExtent; + out_ext->maxScaledImageExtent = in_ext->maxScaledImageExtent; out_header = (void *)out_ext; break; } @@ -37408,54 +37408,27 @@ static void convert_VkPhysicalDeviceToolProperties_array_host_to_win32(const VkP for (i = 0; i < count; i++) { convert_VkPhysicalDeviceToolProperties_host_to_win32(&in[i], &out[i]); - } -} - -static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoCapabilitiesKHR32 *in, VkVideoCapabilitiesKHR *out) -{ - const VkBaseInStructure32 *in_header; - VkBaseOutStructure *out_header = (void *)out; - - if (!in) return; - - out->sType = in->sType; - out->pNext = NULL; - - for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) - { - switch (in_header->sType) - { - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: - { - VkVideoEncodeQuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; - out_ext->pNext = NULL; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: - { - VkVideoEncodeH264QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; - out_ext->pNext = NULL; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: + } +} + +static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_context *ctx, const VkVideoCapabilitiesKHR32 *in, VkVideoCapabilitiesKHR *out) +{ + const VkBaseInStructure32 *in_header; + VkBaseOutStructure *out_header = (void *)out; + + if (!in) return; + + out->sType = in->sType; + out->pNext = NULL; + + for (in_header = UlongToPtr(in->pNext); in_header; in_header = UlongToPtr(in_header->pNext)) + { + switch (in_header->sType) { - VkVideoEncodeH265QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; - out_ext->pNext = NULL; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: { - VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; + VkVideoDecodeAV1CapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -37488,10 +37461,19 @@ static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_conte out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: { - VkVideoDecodeAV1CapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR; + VkVideoEncodeAV1CapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -37515,10 +37497,19 @@ static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_conte out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: { - VkVideoEncodeAV1CapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; + VkVideoEncodeH264QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeH265QuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -37533,6 +37524,15 @@ static void convert_VkVideoCapabilitiesKHR_win32_to_host(struct conversion_conte out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeQuantizationMapCapabilitiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->pNext = NULL; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -37561,42 +37561,12 @@ static void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabiliti { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: - { - VkVideoEncodeQuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR); - const VkVideoEncodeQuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeQuantizationMapCapabilitiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; - out_ext->maxQuantizationMapExtent = in_ext->maxQuantizationMapExtent; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: - { - VkVideoEncodeH264QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR); - const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; - out_ext->minQpDelta = in_ext->minQpDelta; - out_ext->maxQpDelta = in_ext->maxQpDelta; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: - { - VkVideoEncodeH265QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR); - const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; - out_ext->minQpDelta = in_ext->minQpDelta; - out_ext->maxQpDelta = in_ext->maxQpDelta; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: { - VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR); - const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; - out_ext->minQIndexDelta = in_ext->minQIndexDelta; - out_ext->maxQIndexDelta = in_ext->maxQIndexDelta; + VkVideoDecodeAV1CapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR); + const VkVideoDecodeAV1CapabilitiesKHR *in_ext = (const VkVideoDecodeAV1CapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR; + out_ext->maxLevel = in_ext->maxLevel; out_header = (void *)out_ext; break; } @@ -37628,12 +37598,45 @@ static void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabiliti out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: { - VkVideoDecodeAV1CapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR); - const VkVideoDecodeAV1CapabilitiesKHR *in_ext = (const VkVideoDecodeAV1CapabilitiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR; + VkVideoEncodeAV1CapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR); + const VkVideoEncodeAV1CapabilitiesKHR *in_ext = (const VkVideoEncodeAV1CapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; + out_ext->flags = in_ext->flags; out_ext->maxLevel = in_ext->maxLevel; + out_ext->codedPictureAlignment = in_ext->codedPictureAlignment; + out_ext->maxTiles = in_ext->maxTiles; + out_ext->minTileSize = in_ext->minTileSize; + out_ext->maxTileSize = in_ext->maxTileSize; + out_ext->superblockSizes = in_ext->superblockSizes; + out_ext->maxSingleReferenceCount = in_ext->maxSingleReferenceCount; + out_ext->singleReferenceNameMask = in_ext->singleReferenceNameMask; + out_ext->maxUnidirectionalCompoundReferenceCount = in_ext->maxUnidirectionalCompoundReferenceCount; + out_ext->maxUnidirectionalCompoundGroup1ReferenceCount = in_ext->maxUnidirectionalCompoundGroup1ReferenceCount; + out_ext->unidirectionalCompoundReferenceNameMask = in_ext->unidirectionalCompoundReferenceNameMask; + out_ext->maxBidirectionalCompoundReferenceCount = in_ext->maxBidirectionalCompoundReferenceCount; + out_ext->maxBidirectionalCompoundGroup1ReferenceCount = in_ext->maxBidirectionalCompoundGroup1ReferenceCount; + out_ext->maxBidirectionalCompoundGroup2ReferenceCount = in_ext->maxBidirectionalCompoundGroup2ReferenceCount; + out_ext->bidirectionalCompoundReferenceNameMask = in_ext->bidirectionalCompoundReferenceNameMask; + out_ext->maxTemporalLayerCount = in_ext->maxTemporalLayerCount; + out_ext->maxSpatialLayerCount = in_ext->maxSpatialLayerCount; + out_ext->maxOperatingPoints = in_ext->maxOperatingPoints; + out_ext->minQIndex = in_ext->minQIndex; + out_ext->maxQIndex = in_ext->maxQIndex; + out_ext->prefersGopRemainingFrames = in_ext->prefersGopRemainingFrames; + out_ext->requiresGopRemainingFrames = in_ext->requiresGopRemainingFrames; + out_ext->stdSyntaxFlags = in_ext->stdSyntaxFlags; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeAV1QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR); + const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeAV1QuantizationMapCapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->minQIndexDelta = in_ext->minQIndexDelta; + out_ext->maxQIndexDelta = in_ext->maxQIndexDelta; out_header = (void *)out_ext; break; } @@ -37673,35 +37676,23 @@ static void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabiliti out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: { - VkVideoEncodeAV1CapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR); - const VkVideoEncodeAV1CapabilitiesKHR *in_ext = (const VkVideoEncodeAV1CapabilitiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR; - out_ext->flags = in_ext->flags; - out_ext->maxLevel = in_ext->maxLevel; - out_ext->codedPictureAlignment = in_ext->codedPictureAlignment; - out_ext->maxTiles = in_ext->maxTiles; - out_ext->minTileSize = in_ext->minTileSize; - out_ext->maxTileSize = in_ext->maxTileSize; - out_ext->superblockSizes = in_ext->superblockSizes; - out_ext->maxSingleReferenceCount = in_ext->maxSingleReferenceCount; - out_ext->singleReferenceNameMask = in_ext->singleReferenceNameMask; - out_ext->maxUnidirectionalCompoundReferenceCount = in_ext->maxUnidirectionalCompoundReferenceCount; - out_ext->maxUnidirectionalCompoundGroup1ReferenceCount = in_ext->maxUnidirectionalCompoundGroup1ReferenceCount; - out_ext->unidirectionalCompoundReferenceNameMask = in_ext->unidirectionalCompoundReferenceNameMask; - out_ext->maxBidirectionalCompoundReferenceCount = in_ext->maxBidirectionalCompoundReferenceCount; - out_ext->maxBidirectionalCompoundGroup1ReferenceCount = in_ext->maxBidirectionalCompoundGroup1ReferenceCount; - out_ext->maxBidirectionalCompoundGroup2ReferenceCount = in_ext->maxBidirectionalCompoundGroup2ReferenceCount; - out_ext->bidirectionalCompoundReferenceNameMask = in_ext->bidirectionalCompoundReferenceNameMask; - out_ext->maxTemporalLayerCount = in_ext->maxTemporalLayerCount; - out_ext->maxSpatialLayerCount = in_ext->maxSpatialLayerCount; - out_ext->maxOperatingPoints = in_ext->maxOperatingPoints; - out_ext->minQIndex = in_ext->minQIndex; - out_ext->maxQIndex = in_ext->maxQIndex; - out_ext->prefersGopRemainingFrames = in_ext->prefersGopRemainingFrames; - out_ext->requiresGopRemainingFrames = in_ext->requiresGopRemainingFrames; - out_ext->stdSyntaxFlags = in_ext->stdSyntaxFlags; + VkVideoEncodeH264QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR); + const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeH264QuantizationMapCapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->minQpDelta = in_ext->minQpDelta; + out_ext->maxQpDelta = in_ext->maxQpDelta; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeH265QuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR); + const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeH265QuantizationMapCapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->minQpDelta = in_ext->minQpDelta; + out_ext->maxQpDelta = in_ext->maxQpDelta; out_header = (void *)out_ext; break; } @@ -37718,6 +37709,15 @@ static void convert_VkVideoCapabilitiesKHR_host_to_win32(const VkVideoCapabiliti out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: + { + VkVideoEncodeQuantizationMapCapabilitiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR); + const VkVideoEncodeQuantizationMapCapabilitiesKHR *in_ext = (const VkVideoEncodeQuantizationMapCapabilitiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR; + out_ext->maxQuantizationMapExtent = in_ext->maxQuantizationMapExtent; + out_header = (void *)out_ext; + break; + } default: break; } @@ -37750,19 +37750,19 @@ static void convert_VkVideoEncodeQualityLevelPropertiesKHR_win32_to_host(struct { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: { - VkVideoEncodeH264QualityLevelPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR; + VkVideoEncodeAV1QualityLevelPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: { - VkVideoEncodeAV1QualityLevelPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR; + VkVideoEncodeH264QualityLevelPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -37789,23 +37789,6 @@ static void convert_VkVideoEncodeQualityLevelPropertiesKHR_host_to_win32(const V { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: - { - VkVideoEncodeH264QualityLevelPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR); - const VkVideoEncodeH264QualityLevelPropertiesKHR *in_ext = (const VkVideoEncodeH264QualityLevelPropertiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR; - out_ext->preferredRateControlFlags = in_ext->preferredRateControlFlags; - out_ext->preferredGopFrameCount = in_ext->preferredGopFrameCount; - out_ext->preferredIdrPeriod = in_ext->preferredIdrPeriod; - out_ext->preferredConsecutiveBFrameCount = in_ext->preferredConsecutiveBFrameCount; - out_ext->preferredTemporalLayerCount = in_ext->preferredTemporalLayerCount; - out_ext->preferredConstantQp = in_ext->preferredConstantQp; - out_ext->preferredMaxL0ReferenceCount = in_ext->preferredMaxL0ReferenceCount; - out_ext->preferredMaxL1ReferenceCount = in_ext->preferredMaxL1ReferenceCount; - out_ext->preferredStdEntropyCodingModeFlag = in_ext->preferredStdEntropyCodingModeFlag; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: { VkVideoEncodeAV1QualityLevelPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR); @@ -37829,6 +37812,23 @@ static void convert_VkVideoEncodeQualityLevelPropertiesKHR_host_to_win32(const V out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: + { + VkVideoEncodeH264QualityLevelPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR); + const VkVideoEncodeH264QualityLevelPropertiesKHR *in_ext = (const VkVideoEncodeH264QualityLevelPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR; + out_ext->preferredRateControlFlags = in_ext->preferredRateControlFlags; + out_ext->preferredGopFrameCount = in_ext->preferredGopFrameCount; + out_ext->preferredIdrPeriod = in_ext->preferredIdrPeriod; + out_ext->preferredConsecutiveBFrameCount = in_ext->preferredConsecutiveBFrameCount; + out_ext->preferredTemporalLayerCount = in_ext->preferredTemporalLayerCount; + out_ext->preferredConstantQp = in_ext->preferredConstantQp; + out_ext->preferredMaxL0ReferenceCount = in_ext->preferredMaxL0ReferenceCount; + out_ext->preferredMaxL1ReferenceCount = in_ext->preferredMaxL1ReferenceCount; + out_ext->preferredStdEntropyCodingModeFlag = in_ext->preferredStdEntropyCodingModeFlag; + out_header = (void *)out_ext; + break; + } default: break; } @@ -37883,10 +37883,10 @@ static void convert_VkVideoFormatPropertiesKHR_win32_to_host(struct conversion_c { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: { - VkVideoFormatQuantizationMapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; + VkVideoFormatAV1QuantizationMapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -37901,10 +37901,10 @@ static void convert_VkVideoFormatPropertiesKHR_win32_to_host(struct conversion_c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: { - VkVideoFormatAV1QuantizationMapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; + VkVideoFormatQuantizationMapPropertiesKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; out_ext->pNext = NULL; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; @@ -37951,12 +37951,12 @@ static void convert_VkVideoFormatPropertiesKHR_host_to_win32(const VkVideoFormat { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: { - VkVideoFormatQuantizationMapPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR); - const VkVideoFormatQuantizationMapPropertiesKHR *in_ext = (const VkVideoFormatQuantizationMapPropertiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; - out_ext->quantizationMapTexelSize = in_ext->quantizationMapTexelSize; + VkVideoFormatAV1QuantizationMapPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR); + const VkVideoFormatAV1QuantizationMapPropertiesKHR *in_ext = (const VkVideoFormatAV1QuantizationMapPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; + out_ext->compatibleSuperblockSizes = in_ext->compatibleSuperblockSizes; out_header = (void *)out_ext; break; } @@ -37969,12 +37969,12 @@ static void convert_VkVideoFormatPropertiesKHR_host_to_win32(const VkVideoFormat out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: { - VkVideoFormatAV1QuantizationMapPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR); - const VkVideoFormatAV1QuantizationMapPropertiesKHR *in_ext = (const VkVideoFormatAV1QuantizationMapPropertiesKHR *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR; - out_ext->compatibleSuperblockSizes = in_ext->compatibleSuperblockSizes; + VkVideoFormatQuantizationMapPropertiesKHR32 *out_ext = find_next_struct32(out_header, VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR); + const VkVideoFormatQuantizationMapPropertiesKHR *in_ext = (const VkVideoFormatQuantizationMapPropertiesKHR *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR; + out_ext->quantizationMapTexelSize = in_ext->quantizationMapTexelSize; out_header = (void *)out_ext; break; } @@ -38898,20 +38898,6 @@ static void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ct out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: - { - VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO; - out_ext->pNext = NULL; - out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount; - out_ext->pWaitSemaphoreValues = UlongToPtr(in_ext->pWaitSemaphoreValues); - out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount; - out_ext->pSignalSemaphoreValues = UlongToPtr(in_ext->pSignalSemaphoreValues); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: { VkFrameBoundaryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -38943,6 +38929,20 @@ static void convert_VkBindSparseInfo_win32_to_host(struct conversion_context *ct out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + { + VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO; + out_ext->pNext = NULL; + out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount; + out_ext->pWaitSemaphoreValues = UlongToPtr(in_ext->pWaitSemaphoreValues); + out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount; + out_ext->pSignalSemaphoreValues = UlongToPtr(in_ext->pSignalSemaphoreValues); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -39021,18 +39021,6 @@ static void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conversion_c { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: - { - VkPresentRegionsKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPresentRegionsKHR32 *in_ext = (const VkPresentRegionsKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR; - out_ext->pNext = NULL; - out_ext->swapchainCount = in_ext->swapchainCount; - out_ext->pRegions = convert_VkPresentRegionKHR_array_win32_to_host(ctx, (const VkPresentRegionKHR32 *)UlongToPtr(in_ext->pRegions), in_ext->swapchainCount); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: { VkDeviceGroupPresentInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -39046,14 +39034,33 @@ static void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conversion_c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: { - VkPresentIdKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPresentIdKHR32 *in_ext = (const VkPresentIdKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR; + VkFrameBoundaryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkFrameBoundaryEXT32 *in_ext = (const VkFrameBoundaryEXT32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT; out_ext->pNext = NULL; - out_ext->swapchainCount = in_ext->swapchainCount; - out_ext->pPresentIds = UlongToPtr(in_ext->pPresentIds); + out_ext->flags = in_ext->flags; + out_ext->frameID = in_ext->frameID; + out_ext->imageCount = in_ext->imageCount; + out_ext->pImages = UlongToPtr(in_ext->pImages); + out_ext->bufferCount = in_ext->bufferCount; + out_ext->pBuffers = UlongToPtr(in_ext->pBuffers); + out_ext->tagName = in_ext->tagName; + out_ext->tagSize = in_ext->tagSize; + out_ext->pTag = UlongToPtr(in_ext->pTag); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + { + VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; + out_ext->pNext = NULL; + out_ext->tensorCount = in_ext->tensorCount; + out_ext->pTensors = UlongToPtr(in_ext->pTensors); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -39070,21 +39077,26 @@ static void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conversion_c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: + case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: { - VkFrameBoundaryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkFrameBoundaryEXT32 *in_ext = (const VkFrameBoundaryEXT32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT; + VkPresentIdKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPresentIdKHR32 *in_ext = (const VkPresentIdKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR; out_ext->pNext = NULL; - out_ext->flags = in_ext->flags; - out_ext->frameID = in_ext->frameID; - out_ext->imageCount = in_ext->imageCount; - out_ext->pImages = UlongToPtr(in_ext->pImages); - out_ext->bufferCount = in_ext->bufferCount; - out_ext->pBuffers = UlongToPtr(in_ext->pBuffers); - out_ext->tagName = in_ext->tagName; - out_ext->tagSize = in_ext->tagSize; - out_ext->pTag = UlongToPtr(in_ext->pTag); + out_ext->swapchainCount = in_ext->swapchainCount; + out_ext->pPresentIds = UlongToPtr(in_ext->pPresentIds); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: + { + VkPresentRegionsKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPresentRegionsKHR32 *in_ext = (const VkPresentRegionsKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR; + out_ext->pNext = NULL; + out_ext->swapchainCount = in_ext->swapchainCount; + out_ext->pRegions = convert_VkPresentRegionKHR_array_win32_to_host(ctx, (const VkPresentRegionKHR32 *)UlongToPtr(in_ext->pRegions), in_ext->swapchainCount); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -39113,18 +39125,6 @@ static void convert_VkPresentInfoKHR_win32_to_unwrapped_host(struct conversion_c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: - { - VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; - out_ext->pNext = NULL; - out_ext->tensorCount = in_ext->tensorCount; - out_ext->pTensors = UlongToPtr(in_ext->pTensors); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } default: FIXME("Unhandled sType %u.\n", in_header->sType); break; @@ -39204,42 +39204,6 @@ static void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: - { - VkProtectedSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkProtectedSubmitInfo32 *in_ext = (const VkProtectedSubmitInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO; - out_ext->pNext = NULL; - out_ext->protectedSubmit = in_ext->protectedSubmit; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: - { - VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO; - out_ext->pNext = NULL; - out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount; - out_ext->pWaitSemaphoreValues = UlongToPtr(in_ext->pWaitSemaphoreValues); - out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount; - out_ext->pSignalSemaphoreValues = UlongToPtr(in_ext->pSignalSemaphoreValues); - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } - case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: - { - VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR; - out_ext->pNext = NULL; - out_ext->counterPassIndex = in_ext->counterPassIndex; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: { VkFrameBoundaryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -39259,6 +39223,18 @@ static void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, c out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + { + VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; + out_ext->pNext = NULL; + out_ext->tensorCount = in_ext->tensorCount; + out_ext->pTensors = UlongToPtr(in_ext->pTensors); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV: { VkLatencySubmissionPresentIdNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -39270,14 +39246,38 @@ static void convert_VkSubmitInfo_win32_to_host(struct conversion_context *ctx, c out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: { - VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; + VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR; out_ext->pNext = NULL; - out_ext->tensorCount = in_ext->tensorCount; - out_ext->pTensors = UlongToPtr(in_ext->pTensors); + out_ext->counterPassIndex = in_ext->counterPassIndex; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: + { + VkProtectedSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkProtectedSubmitInfo32 *in_ext = (const VkProtectedSubmitInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO; + out_ext->pNext = NULL; + out_ext->protectedSubmit = in_ext->protectedSubmit; + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + { + VkTimelineSemaphoreSubmitInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkTimelineSemaphoreSubmitInfo32 *in_ext = (const VkTimelineSemaphoreSubmitInfo32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO; + out_ext->pNext = NULL; + out_ext->waitSemaphoreValueCount = in_ext->waitSemaphoreValueCount; + out_ext->pWaitSemaphoreValues = UlongToPtr(in_ext->pWaitSemaphoreValues); + out_ext->signalSemaphoreValueCount = in_ext->signalSemaphoreValueCount; + out_ext->pSignalSemaphoreValues = UlongToPtr(in_ext->pSignalSemaphoreValues); out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break; @@ -39472,17 +39472,6 @@ static void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, { switch (in_header->sType) { - case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: - { - VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR; - out_ext->pNext = NULL; - out_ext->counterPassIndex = in_ext->counterPassIndex; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: { VkFrameBoundaryEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -39502,6 +39491,18 @@ static void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, out_header = (void *)out_ext; break; } + case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + { + VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; + out_ext->pNext = NULL; + out_ext->tensorCount = in_ext->tensorCount; + out_ext->pTensors = UlongToPtr(in_ext->pTensors); + out_header->pNext = (void *)out_ext; + out_header = (void *)out_ext; + break; + } case VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV: { VkLatencySubmissionPresentIdNV *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -39513,14 +39514,13 @@ static void convert_VkSubmitInfo2_win32_to_host(struct conversion_context *ctx, out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: { - VkFrameBoundaryTensorsARM *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkFrameBoundaryTensorsARM32 *in_ext = (const VkFrameBoundaryTensorsARM32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM; + VkPerformanceQuerySubmitInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); + const VkPerformanceQuerySubmitInfoKHR32 *in_ext = (const VkPerformanceQuerySubmitInfoKHR32 *)in_header; + out_ext->sType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR; out_ext->pNext = NULL; - out_ext->tensorCount = in_ext->tensorCount; - out_ext->pTensors = UlongToPtr(in_ext->pTensors); + out_ext->counterPassIndex = in_ext->counterPassIndex; out_header->pNext = (void *)out_ext; out_header = (void *)out_ext; break;

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8901

Rémi Bernon

9:37 a.m.

New subject: [PATCH 6/6] winevulkan: Avoid converting unexposed extensions structs.

From: Rémi Bernon rbernon@codeweavers.com

--- dlls/winevulkan/make_vulkan | 13 ++++++++-- dlls/winevulkan/vulkan_thunks.c | 44 --------------------------------- 2 files changed, 11 insertions(+), 46 deletions(-)

diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan index 40726fc6e2e..c9da1db9f61 100755 --- a/dlls/winevulkan/make_vulkan +++ b/dlls/winevulkan/make_vulkan @@ -1956,12 +1956,18 @@ class VkStruct(Sequence): structs[member.type].alias.set_order(self.order, structs) structs[member.type].set_order(self.order, structs)

+ @property + def extension(self): + return self.registry.types[self.name]["extension"] + @property def struct_extensions(self): if self._extensions is None: self._extensions = []

def is_struct_extension(s): + if s.extension in UNEXPOSED_EXTENSIONS: + return False return not s.alias and self.name in s.structextends

structs = sorted(self.registry.structs, key=lambda s: s.name) @@ -3428,8 +3434,9 @@ class VkRegistry(object): # We don't even parse <type category="include"> tags. # Therefore just skip any types that aren't found. if t.attrib["name"] in self.types: - type_info = self.types[t.attrib["name"]]["data"] - self._require_type(type_info) + type_info = self.types[t.attrib["name"]] + type_info["extension"] = ext_name + self._require_type(type_info["data"]) feature = require.attrib.get("feature") if feature and not self._is_feature_supported(feature): continue @@ -3518,6 +3525,7 @@ class VkRegistry(object): type_info = {} type_info["category"] = t.attrib.get("category", None) type_info["requires"] = t.attrib.get("requires", None) + type_info["extension"] = None

# We parse aliases in a second pass when we know more. alias = t.attrib.get("alias") @@ -3625,6 +3633,7 @@ class VkRegistry(object): type_info = {} type_info["category"] = t.attrib.get("category") type_info["name"] = t.attrib.get("name") + type_info["extension"] = None

alias = t.attrib.get("alias")

diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c index eb5c1921dbc..e4f15aea45c 100644 --- a/dlls/winevulkan/vulkan_thunks.c +++ b/dlls/winevulkan/vulkan_thunks.c @@ -3102,15 +3102,6 @@ typedef struct VkExportMemoryAllocateInfo32 } VkExportMemoryAllocateInfo32; typedef VkExportMemoryAllocateInfo32 VkExportMemoryAllocateInfoKHR32;

-typedef struct VkExportMemoryWin32HandleInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - PTR32 pAttributes; - DWORD dwAccess; - LPCWSTR name; -} VkExportMemoryWin32HandleInfoKHR32; - typedef struct VkExportSemaphoreCreateInfo32 { VkStructureType sType; @@ -3632,15 +3623,6 @@ typedef struct VkImportMemoryHostPointerInfoEXT32 PTR32 pHostPointer; } VkImportMemoryHostPointerInfoEXT32;

-typedef struct VkImportMemoryWin32HandleInfoKHR32 -{ - VkStructureType sType; - PTR32 pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - HANDLE handle; - LPCWSTR name; -} VkImportMemoryWin32HandleInfoKHR32; - typedef struct VkIndirectCommandsLayoutCreateInfoEXT32 { VkStructureType sType; @@ -9698,19 +9680,6 @@ static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: - { - VkExportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkExportMemoryWin32HandleInfoKHR32 *in_ext = (const VkExportMemoryWin32HandleInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR; - out_ext->pNext = NULL; - out_ext->pAttributes = UlongToPtr(in_ext->pAttributes); - out_ext->dwAccess = in_ext->dwAccess; - out_ext->name = in_ext->name; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: { VkImportMemoryHostPointerInfoEXT *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); @@ -9723,19 +9692,6 @@ static void convert_VkMemoryAllocateInfo_win32_to_host(struct conversion_context out_header = (void *)out_ext; break; } - case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: - { - VkImportMemoryWin32HandleInfoKHR *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext)); - const VkImportMemoryWin32HandleInfoKHR32 *in_ext = (const VkImportMemoryWin32HandleInfoKHR32 *)in_header; - out_ext->sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR; - out_ext->pNext = NULL; - out_ext->handleType = in_ext->handleType; - out_ext->handle = in_ext->handle; - out_ext->name = in_ext->name; - out_header->pNext = (void *)out_ext; - out_header = (void *)out_ext; - break; - } case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: { VkMemoryAllocateFlagsInfo *out_ext = conversion_context_alloc(ctx, sizeof(*out_ext));

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8901

Rémi Bernon (＠rbernon)

9:38 a.m.

This also exposes VK_EXT_map_memory_placed, we still want to convert its structs as it's used from client side and I'm not sure why it's not exposed.

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/8901#note_114853

Rémi Bernon (＠rbernon)

9:41 a.m.

New subject: [PATCH 0/5] MR8901: winevulkan: Simplify struct conversion and struct extension enumerations.

Ah nevermind I thought the placed allocations were done on the client side but I see it's actually all in win32u, so we don't need the struct conversions or to expose the extension. It possibly could be exposed but that might conflict with our use of it and I'll keep it hidden for now.

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/8901#note_114854

Age (days ago)

Last active (days ago)

wine-gitlab@winehq.org

8 comments

2 participants

tags (0)

participants (2)

Rémi Bernon
Rémi Bernon (＠rbernon)