From 5ceb9ed481e58e705d0d9b5326537daedd06b97d Mon Sep 17 00:00:00 2001 From: Jon Leech Date: Fri, 4 Apr 2025 04:43:32 -0700 Subject: [PATCH] Update for Vulkan-Docs 1.4.312 --- include/vulkan/vulkan.cppm | 67 + include/vulkan/vulkan.hpp | 164 +- include/vulkan/vulkan_core.h | 148 +- include/vulkan/vulkan_enums.hpp | 57 +- .../vulkan/vulkan_extension_inspection.hpp | 2098 +++++++++++- include/vulkan/vulkan_format_traits.hpp | 54 +- include/vulkan/vulkan_funcs.hpp | 231 ++ include/vulkan/vulkan_handles.hpp | 221 ++ include/vulkan/vulkan_hash.hpp | 160 + include/vulkan/vulkan_raii.hpp | 1232 ++++--- include/vulkan/vulkan_shared.hpp | 11 + include/vulkan/vulkan_static_assertions.hpp | 74 + include/vulkan/vulkan_structs.hpp | 1214 +++++++ include/vulkan/vulkan_to_string.hpp | 49 + registry/validusage.json | 2824 +++++++++++++---- registry/vk.xml | 286 +- 16 files changed, 7615 insertions(+), 1275 deletions(-) diff --git a/include/vulkan/vulkan.cppm b/include/vulkan/vulkan.cppm index 7b7583d..fd46544 100644 --- a/include/vulkan/vulkan.cppm +++ b/include/vulkan/vulkan.cppm @@ -753,6 +753,10 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagBitsNV; using VULKAN_HPP_NAMESPACE::DeviceDiagnosticsConfigFlagsNV; + //=== VK_QCOM_tile_shading === + using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagBitsQCOM; + using VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagsQCOM; + #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === using VULKAN_HPP_NAMESPACE::ExportMetalObjectTypeFlagBitsEXT; @@ -2092,6 +2096,10 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::NVCudaKernelLaunchSpecVersion; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + using VULKAN_HPP_NAMESPACE::QCOMTileShadingExtensionName; + using VULKAN_HPP_NAMESPACE::QCOMTileShadingSpecVersion; + //=== VK_NV_low_latency === using VULKAN_HPP_NAMESPACE::NVLowLatencyExtensionName; using VULKAN_HPP_NAMESPACE::NVLowLatencySpecVersion; @@ -2653,6 +2661,10 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::NVRawAccessChainsExtensionName; using VULKAN_HPP_NAMESPACE::NVRawAccessChainsSpecVersion; + //=== VK_NV_external_compute_queue === + using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueExtensionName; + using VULKAN_HPP_NAMESPACE::NVExternalComputeQueueSpecVersion; + //=== VK_KHR_shader_relaxed_extended_instruction === using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionExtensionName; using VULKAN_HPP_NAMESPACE::KHRShaderRelaxedExtendedInstructionSpecVersion; @@ -4132,6 +4144,14 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_NAMESPACE::PhysicalDeviceCudaKernelLaunchPropertiesNV; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + using VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM; + using VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM; + using VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM; + using VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM; + //=== VK_NV_low_latency === using VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV; @@ -4697,6 +4717,12 @@ export namespace VULKAN_HPP_NAMESPACE //=== VK_NV_raw_access_chains === using VULKAN_HPP_NAMESPACE::PhysicalDeviceRawAccessChainsFeaturesNV; + //=== VK_NV_external_compute_queue === + using VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV; + using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV; + using VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV; + using VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV; + //=== VK_KHR_shader_relaxed_extended_instruction === using VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; @@ -4940,6 +4966,9 @@ export namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_pipeline_binary === using VULKAN_HPP_NAMESPACE::PipelineBinaryKHR; + //=== VK_NV_external_compute_queue === + using VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV; + //=== VK_EXT_device_generated_commands === using VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT; using VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT; @@ -5046,6 +5075,9 @@ export namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_pipeline_binary === using VULKAN_HPP_NAMESPACE::UniquePipelineBinaryKHR; + //=== VK_NV_external_compute_queue === + using VULKAN_HPP_NAMESPACE::UniqueExternalComputeQueueNV; + //=== VK_EXT_device_generated_commands === using VULKAN_HPP_NAMESPACE::UniqueHandleTraits; using VULKAN_HPP_NAMESPACE::UniqueIndirectCommandsLayoutEXT; @@ -5157,6 +5189,9 @@ export namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_pipeline_binary === using VULKAN_HPP_NAMESPACE::SharedPipelineBinaryKHR; + //=== VK_NV_external_compute_queue === + using VULKAN_HPP_NAMESPACE::SharedExternalComputeQueueNV; + //=== VK_EXT_device_generated_commands === using VULKAN_HPP_NAMESPACE::SharedHandleTraits; using VULKAN_HPP_NAMESPACE::SharedIndirectCommandsLayoutEXT; @@ -5212,6 +5247,7 @@ export namespace VULKAN_HPP_NAMESPACE //====================================== using VULKAN_HPP_NAMESPACE::getDeprecatedExtensions; using VULKAN_HPP_NAMESPACE::getDeviceExtensions; + using VULKAN_HPP_NAMESPACE::getExtensionDepends; using VULKAN_HPP_NAMESPACE::getExtensionDeprecatedBy; using VULKAN_HPP_NAMESPACE::getExtensionObsoletedBy; using VULKAN_HPP_NAMESPACE::getExtensionPromotedTo; @@ -5351,6 +5387,9 @@ export namespace VULKAN_HPP_NAMESPACE using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR; using VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHRs; + //=== VK_NV_external_compute_queue === + using VULKAN_HPP_RAII_NAMESPACE::ExternalComputeQueueNV; + //=== VK_EXT_device_generated_commands === using VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutEXT; using VULKAN_HPP_RAII_NAMESPACE::IndirectExecutionSetEXT; @@ -5523,6 +5562,10 @@ export namespace std template <> struct hash; + //=== VK_NV_external_compute_queue === + template <> + struct hash; + //=== VK_EXT_device_generated_commands === template <> struct hash; @@ -7413,6 +7456,20 @@ export namespace std struct hash; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + //=== VK_NV_low_latency === template <> struct hash; @@ -8303,6 +8360,16 @@ export namespace std template <> struct hash; + //=== VK_NV_external_compute_queue === + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + template <> + struct hash; + //=== VK_KHR_shader_relaxed_extended_instruction === template <> struct hash; diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index cabbead..172a45a 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -63,7 +63,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include #endif -static_assert( VK_HEADER_VERSION == 311, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 312, "Wrong VK_HEADER_VERSION!" ); // includes through some other header // this results in major(x) being resolved to gnu_dev_major(x) @@ -4951,6 +4951,23 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + + void vkCmdDispatchTileQCOM( VkCommandBuffer commandBuffer ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdDispatchTileQCOM( commandBuffer ); + } + + void vkCmdBeginPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM * pPerTileBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBeginPerTileExecutionQCOM( commandBuffer, pPerTileBeginInfo ); + } + + void vkCmdEndPerTileExecutionQCOM( VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM * pPerTileEndInfo ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdEndPerTileExecutionQCOM( commandBuffer, pPerTileEndInfo ); + } + # if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === @@ -6095,6 +6112,30 @@ namespace VULKAN_HPP_NAMESPACE return ::vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo ); } + //=== VK_NV_external_compute_queue === + + VkResult vkCreateExternalComputeQueueNV( VkDevice device, + const VkExternalComputeQueueCreateInfoNV * pCreateInfo, + const VkAllocationCallbacks * pAllocator, + VkExternalComputeQueueNV * pExternalQueue ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateExternalComputeQueueNV( device, pCreateInfo, pAllocator, pExternalQueue ); + } + + void vkDestroyExternalComputeQueueNV( VkDevice device, + VkExternalComputeQueueNV externalQueue, + const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyExternalComputeQueueNV( device, externalQueue, pAllocator ); + } + + void vkGetExternalComputeQueueDataNV( VkExternalComputeQueueNV externalQueue, + VkExternalComputeQueueDataParamsNV * params, + void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetExternalComputeQueueDataNV( externalQueue, params, pData ); + } + //=== VK_NV_cluster_acceleration_structure === void vkGetClusterAccelerationStructureBuildSizesNV( VkDevice device, @@ -8344,6 +8385,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto NVCudaKernelLaunchSpecVersion = VK_NV_CUDA_KERNEL_LAUNCH_SPEC_VERSION; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileShadingExtensionName = VK_QCOM_TILE_SHADING_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto QCOMTileShadingSpecVersion = VK_QCOM_TILE_SHADING_SPEC_VERSION; + //=== VK_NV_low_latency === VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencyExtensionName = VK_NV_LOW_LATENCY_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto NVLowLatencySpecVersion = VK_NV_LOW_LATENCY_SPEC_VERSION; @@ -8900,6 +8945,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsExtensionName = VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto NVRawAccessChainsSpecVersion = VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION; + //=== VK_NV_external_compute_queue === + VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalComputeQueueExtensionName = VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME; + VULKAN_HPP_CONSTEXPR_INLINE auto NVExternalComputeQueueSpecVersion = VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION; + //=== VK_KHR_shader_relaxed_extended_instruction === VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionExtensionName = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME; VULKAN_HPP_CONSTEXPR_INLINE auto KHRShaderRelaxedExtendedInstructionSpecVersion = VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION; @@ -14107,6 +14156,70 @@ namespace VULKAN_HPP_NAMESPACE }; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_NV_low_latency === template <> struct StructExtends @@ -17401,6 +17514,25 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_NV_external_compute_queue === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_KHR_shader_relaxed_extended_instruction === template <> struct StructExtends @@ -19051,6 +19183,11 @@ namespace VULKAN_HPP_NAMESPACE PFN_dummy vkCmdCudaLaunchKernelNV_placeholder = 0; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + PFN_vkCmdDispatchTileQCOM vkCmdDispatchTileQCOM = 0; + PFN_vkCmdBeginPerTileExecutionQCOM vkCmdBeginPerTileExecutionQCOM = 0; + PFN_vkCmdEndPerTileExecutionQCOM vkCmdEndPerTileExecutionQCOM = 0; + #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0; @@ -19347,6 +19484,11 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT = 0; PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0; + //=== VK_NV_external_compute_queue === + PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV = 0; + PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0; + PFN_vkGetExternalComputeQueueDataNV vkGetExternalComputeQueueDataNV = 0; + //=== VK_NV_cluster_acceleration_structure === PFN_vkGetClusterAccelerationStructureBuildSizesNV vkGetClusterAccelerationStructureBuildSizesNV = 0; PFN_vkCmdBuildClusterAccelerationStructureIndirectNV vkCmdBuildClusterAccelerationStructureIndirectNV = 0; @@ -20519,6 +20661,11 @@ namespace VULKAN_HPP_NAMESPACE vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetInstanceProcAddr( instance, "vkCmdCudaLaunchKernelNV" ) ); #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + vkCmdDispatchTileQCOM = PFN_vkCmdDispatchTileQCOM( vkGetInstanceProcAddr( instance, "vkCmdDispatchTileQCOM" ) ); + vkCmdBeginPerTileExecutionQCOM = PFN_vkCmdBeginPerTileExecutionQCOM( vkGetInstanceProcAddr( instance, "vkCmdBeginPerTileExecutionQCOM" ) ); + vkCmdEndPerTileExecutionQCOM = PFN_vkCmdEndPerTileExecutionQCOM( vkGetInstanceProcAddr( instance, "vkCmdEndPerTileExecutionQCOM" ) ); + #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetInstanceProcAddr( instance, "vkExportMetalObjectsEXT" ) ); @@ -20886,6 +21033,11 @@ namespace VULKAN_HPP_NAMESPACE vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetInstanceProcAddr( instance, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) ); + //=== VK_NV_external_compute_queue === + vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkCreateExternalComputeQueueNV" ) ); + vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetInstanceProcAddr( instance, "vkDestroyExternalComputeQueueNV" ) ); + vkGetExternalComputeQueueDataNV = PFN_vkGetExternalComputeQueueDataNV( vkGetInstanceProcAddr( instance, "vkGetExternalComputeQueueDataNV" ) ); + //=== VK_NV_cluster_acceleration_structure === vkGetClusterAccelerationStructureBuildSizesNV = PFN_vkGetClusterAccelerationStructureBuildSizesNV( vkGetInstanceProcAddr( instance, "vkGetClusterAccelerationStructureBuildSizesNV" ) ); @@ -21729,6 +21881,11 @@ namespace VULKAN_HPP_NAMESPACE vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetDeviceProcAddr( device, "vkCmdCudaLaunchKernelNV" ) ); #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + vkCmdDispatchTileQCOM = PFN_vkCmdDispatchTileQCOM( vkGetDeviceProcAddr( device, "vkCmdDispatchTileQCOM" ) ); + vkCmdBeginPerTileExecutionQCOM = PFN_vkCmdBeginPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdBeginPerTileExecutionQCOM" ) ); + vkCmdEndPerTileExecutionQCOM = PFN_vkCmdEndPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdEndPerTileExecutionQCOM" ) ); + #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) ); @@ -22062,6 +22219,11 @@ namespace VULKAN_HPP_NAMESPACE vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) ); + //=== VK_NV_external_compute_queue === + vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) ); + vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) ); + vkGetExternalComputeQueueDataNV = PFN_vkGetExternalComputeQueueDataNV( vkGetDeviceProcAddr( device, "vkGetExternalComputeQueueDataNV" ) ); + //=== VK_NV_cluster_acceleration_structure === vkGetClusterAccelerationStructureBuildSizesNV = PFN_vkGetClusterAccelerationStructureBuildSizesNV( vkGetDeviceProcAddr( device, "vkGetClusterAccelerationStructureBuildSizesNV" ) ); diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h index 5de5a3e..35e5091 100644 --- a/include/vulkan/vulkan_core.h +++ b/include/vulkan/vulkan_core.h @@ -69,7 +69,7 @@ extern "C" { #define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 311 +#define VK_HEADER_VERSION 312 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) @@ -878,6 +878,12 @@ typedef enum VkStructureType { #ifdef VK_ENABLE_BETA_EXTENSIONS VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV = 1000307004, #endif + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM = 1000309000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM = 1000309001, + VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM = 1000309002, + VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM = 1000309003, + VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM = 1000309004, + VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM = 1000309005, VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV = 1000310000, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000, VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT = 1000311001, @@ -1175,6 +1181,10 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR = 1000553007, VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR = 1000553008, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV = 1000555000, + VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV = 1000556000, + VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV = 1000556001, + VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV = 1000556002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV = 1000556003, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR = 1000558000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV = 1000559000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR = 1000562000, @@ -1593,6 +1603,7 @@ typedef enum VkObjectType { VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, VK_OBJECT_TYPE_SHADER_EXT = 1000482000, VK_OBJECT_TYPE_PIPELINE_BINARY_KHR = 1000483000, + VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV = 1000556000, VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT = 1000572000, VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT = 1000572001, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, @@ -2991,6 +3002,7 @@ typedef enum VkSubpassDescriptionFlagBits { VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0x00000004, VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0x00000008, + VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM = 0x00000100, VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT = 0x00000010, VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000020, VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000040, @@ -6890,6 +6902,8 @@ static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x8000000 static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM = 0x8000000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM = 0x10000000000000ULL; static const VkAccessFlagBits2 VK_ACCESS_2_NONE_KHR = 0ULL; static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL; static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL; @@ -17175,6 +17189,85 @@ VKAPI_ATTR void VKAPI_CALL vkCmdCudaLaunchKernelNV( #endif +// VK_QCOM_tile_shading is a preprocessor guard. Do not pass it to API calls. +#define VK_QCOM_tile_shading 1 +#define VK_QCOM_TILE_SHADING_SPEC_VERSION 1 +#define VK_QCOM_TILE_SHADING_EXTENSION_NAME "VK_QCOM_tile_shading" + +typedef enum VkTileShadingRenderPassFlagBitsQCOM { + VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM = 0x00000001, + VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM = 0x00000002, + VK_TILE_SHADING_RENDER_PASS_FLAG_BITS_MAX_ENUM_QCOM = 0x7FFFFFFF +} VkTileShadingRenderPassFlagBitsQCOM; +typedef VkFlags VkTileShadingRenderPassFlagsQCOM; +typedef struct VkPhysicalDeviceTileShadingFeaturesQCOM { + VkStructureType sType; + void* 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; +} VkPhysicalDeviceTileShadingFeaturesQCOM; + +typedef struct VkPhysicalDeviceTileShadingPropertiesQCOM { + VkStructureType sType; + void* pNext; + uint32_t maxApronSize; + VkBool32 preferNonCoherent; + VkExtent2D tileGranularity; + VkExtent2D maxTileShadingRate; +} VkPhysicalDeviceTileShadingPropertiesQCOM; + +typedef struct VkRenderPassTileShadingCreateInfoQCOM { + VkStructureType sType; + const void* pNext; + VkTileShadingRenderPassFlagsQCOM flags; + VkExtent2D tileApronSize; +} VkRenderPassTileShadingCreateInfoQCOM; + +typedef struct VkPerTileBeginInfoQCOM { + VkStructureType sType; + const void* pNext; +} VkPerTileBeginInfoQCOM; + +typedef struct VkPerTileEndInfoQCOM { + VkStructureType sType; + const void* pNext; +} VkPerTileEndInfoQCOM; + +typedef struct VkDispatchTileInfoQCOM { + VkStructureType sType; + const void* pNext; +} VkDispatchTileInfoQCOM; + +typedef void (VKAPI_PTR *PFN_vkCmdDispatchTileQCOM)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdBeginPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileBeginInfoQCOM* pPerTileBeginInfo); +typedef void (VKAPI_PTR *PFN_vkCmdEndPerTileExecutionQCOM)(VkCommandBuffer commandBuffer, const VkPerTileEndInfoQCOM* pPerTileEndInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR void VKAPI_CALL vkCmdDispatchTileQCOM( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdBeginPerTileExecutionQCOM( + VkCommandBuffer commandBuffer, + const VkPerTileBeginInfoQCOM* pPerTileBeginInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdEndPerTileExecutionQCOM( + VkCommandBuffer commandBuffer, + const VkPerTileEndInfoQCOM* pPerTileEndInfo); +#endif + + // VK_NV_low_latency is a preprocessor guard. Do not pass it to API calls. #define VK_NV_low_latency 1 #define VK_NV_LOW_LATENCY_SPEC_VERSION 1 @@ -20578,6 +20671,59 @@ typedef struct VkPhysicalDeviceRawAccessChainsFeaturesNV { +// VK_NV_external_compute_queue is a preprocessor guard. Do not pass it to API calls. +#define VK_NV_external_compute_queue 1 +VK_DEFINE_HANDLE(VkExternalComputeQueueNV) +#define VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION 1 +#define VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME "VK_NV_external_compute_queue" +typedef struct VkExternalComputeQueueDeviceCreateInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t reservedExternalQueues; +} VkExternalComputeQueueDeviceCreateInfoNV; + +typedef struct VkExternalComputeQueueCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkQueue preferredQueue; +} VkExternalComputeQueueCreateInfoNV; + +typedef struct VkExternalComputeQueueDataParamsNV { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndex; +} VkExternalComputeQueueDataParamsNV; + +typedef struct VkPhysicalDeviceExternalComputeQueuePropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t externalDataSize; + uint32_t maxExternalQueues; +} VkPhysicalDeviceExternalComputeQueuePropertiesNV; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateExternalComputeQueueNV)(VkDevice device, const VkExternalComputeQueueCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkExternalComputeQueueNV* pExternalQueue); +typedef void (VKAPI_PTR *PFN_vkDestroyExternalComputeQueueNV)(VkDevice device, VkExternalComputeQueueNV externalQueue, const VkAllocationCallbacks* pAllocator); +typedef void (VKAPI_PTR *PFN_vkGetExternalComputeQueueDataNV)(VkExternalComputeQueueNV externalQueue, VkExternalComputeQueueDataParamsNV* params, void* pData); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateExternalComputeQueueNV( + VkDevice device, + const VkExternalComputeQueueCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkExternalComputeQueueNV* pExternalQueue); + +VKAPI_ATTR void VKAPI_CALL vkDestroyExternalComputeQueueNV( + VkDevice device, + VkExternalComputeQueueNV externalQueue, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR void VKAPI_CALL vkGetExternalComputeQueueDataNV( + VkExternalComputeQueueNV externalQueue, + VkExternalComputeQueueDataParamsNV* params, + void* pData); +#endif + + // VK_NV_command_buffer_inheritance is a preprocessor guard. Do not pass it to API calls. #define VK_NV_command_buffer_inheritance 1 #define VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION 1 diff --git a/include/vulkan/vulkan_enums.hpp b/include/vulkan/vulkan_enums.hpp index 4c48b5e..bb5ad5f 100644 --- a/include/vulkan/vulkan_enums.hpp +++ b/include/vulkan/vulkan_enums.hpp @@ -1209,7 +1209,13 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceCudaKernelLaunchFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV, ePhysicalDeviceCudaKernelLaunchPropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - eQueryLowLatencySupportNV = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV, + ePhysicalDeviceTileShadingFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM, + ePhysicalDeviceTileShadingPropertiesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM, + eRenderPassTileShadingCreateInfoQCOM = VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM, + ePerTileBeginInfoQCOM = VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM, + ePerTileEndInfoQCOM = VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM, + eDispatchTileInfoQCOM = VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM, + eQueryLowLatencySupportNV = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV, #if defined( VK_USE_PLATFORM_METAL_EXT ) eExportMetalObjectCreateInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT, eExportMetalObjectsInfoEXT = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT, @@ -1520,6 +1526,10 @@ namespace VULKAN_HPP_NAMESPACE eVideoEncodeAv1QuantizationMapCapabilitiesKHR = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR, eVideoFormatAv1QuantizationMapPropertiesKHR = VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR, ePhysicalDeviceRawAccessChainsFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV, + eExternalComputeQueueDeviceCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV, + eExternalComputeQueueCreateInfoNV = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV, + eExternalComputeQueueDataParamsNV = VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV, + ePhysicalDeviceExternalComputeQueuePropertiesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV, ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR, ePhysicalDeviceCommandBufferInheritanceFeaturesNV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV, ePhysicalDeviceMaintenance7FeaturesKHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR, @@ -1664,6 +1674,7 @@ namespace VULKAN_HPP_NAMESPACE eOpticalFlowSessionNV = VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV, eShaderEXT = VK_OBJECT_TYPE_SHADER_EXT, ePipelineBinaryKHR = VK_OBJECT_TYPE_PIPELINE_BINARY_KHR, + eExternalComputeQueueNV = VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV, eIndirectCommandsLayoutEXT = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT, eIndirectExecutionSetEXT = VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT }; @@ -3813,6 +3824,7 @@ namespace VULKAN_HPP_NAMESPACE ePerViewPositionXOnlyNVX = VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX, eFragmentRegionQCOM = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM, eShaderResolveQCOM = VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM, + eTileShadingApronQCOM = VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM, eRasterizationOrderAttachmentColorAccessEXT = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT, eRasterizationOrderAttachmentColorAccessARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM, eRasterizationOrderAttachmentDepthAccessEXT = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, @@ -3831,7 +3843,7 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; static VULKAN_HPP_CONST_OR_CONSTEXPR SubpassDescriptionFlags allFlags = SubpassDescriptionFlagBits::ePerViewAttributesNVX | SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX | - SubpassDescriptionFlagBits::eFragmentRegionQCOM | SubpassDescriptionFlagBits::eShaderResolveQCOM | + SubpassDescriptionFlagBits::eFragmentRegionQCOM | SubpassDescriptionFlagBits::eShaderResolveQCOM | SubpassDescriptionFlagBits::eTileShadingApronQCOM | SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT | SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT | SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT | SubpassDescriptionFlagBits::eEnableLegacyDitheringEXT; }; @@ -4735,6 +4747,8 @@ namespace VULKAN_HPP_NAMESPACE eVideoDecodeWriteKHR = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR, eVideoEncodeReadKHR = VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR, eVideoEncodeWriteKHR = VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR, + eShaderTileAttachmentReadQCOM = VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM, + eShaderTileAttachmentWriteQCOM = VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM, eTransformFeedbackWriteEXT = VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, eTransformFeedbackCounterReadEXT = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT, eTransformFeedbackCounterWriteEXT = VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT, @@ -4778,12 +4792,13 @@ namespace VULKAN_HPP_NAMESPACE AccessFlagBits2::eHostWrite | AccessFlagBits2::eMemoryRead | AccessFlagBits2::eMemoryWrite | AccessFlagBits2::eShaderSampledRead | AccessFlagBits2::eShaderStorageRead | AccessFlagBits2::eShaderStorageWrite | AccessFlagBits2::eVideoDecodeReadKHR | AccessFlagBits2::eVideoDecodeWriteKHR | AccessFlagBits2::eVideoEncodeReadKHR | AccessFlagBits2::eVideoEncodeWriteKHR | - AccessFlagBits2::eTransformFeedbackWriteEXT | AccessFlagBits2::eTransformFeedbackCounterReadEXT | AccessFlagBits2::eTransformFeedbackCounterWriteEXT | - AccessFlagBits2::eConditionalRenderingReadEXT | AccessFlagBits2::eCommandPreprocessReadEXT | AccessFlagBits2::eCommandPreprocessWriteEXT | - AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR | AccessFlagBits2::eAccelerationStructureReadKHR | - AccessFlagBits2::eAccelerationStructureWriteKHR | AccessFlagBits2::eFragmentDensityMapReadEXT | AccessFlagBits2::eColorAttachmentReadNoncoherentEXT | - AccessFlagBits2::eDescriptorBufferReadEXT | AccessFlagBits2::eInvocationMaskReadHUAWEI | AccessFlagBits2::eShaderBindingTableReadKHR | - AccessFlagBits2::eMicromapReadEXT | AccessFlagBits2::eMicromapWriteEXT | AccessFlagBits2::eOpticalFlowReadNV | AccessFlagBits2::eOpticalFlowWriteNV; + AccessFlagBits2::eShaderTileAttachmentReadQCOM | AccessFlagBits2::eShaderTileAttachmentWriteQCOM | AccessFlagBits2::eTransformFeedbackWriteEXT | + AccessFlagBits2::eTransformFeedbackCounterReadEXT | AccessFlagBits2::eTransformFeedbackCounterWriteEXT | AccessFlagBits2::eConditionalRenderingReadEXT | + AccessFlagBits2::eCommandPreprocessReadEXT | AccessFlagBits2::eCommandPreprocessWriteEXT | AccessFlagBits2::eFragmentShadingRateAttachmentReadKHR | + AccessFlagBits2::eAccelerationStructureReadKHR | AccessFlagBits2::eAccelerationStructureWriteKHR | AccessFlagBits2::eFragmentDensityMapReadEXT | + AccessFlagBits2::eColorAttachmentReadNoncoherentEXT | AccessFlagBits2::eDescriptorBufferReadEXT | AccessFlagBits2::eInvocationMaskReadHUAWEI | + AccessFlagBits2::eShaderBindingTableReadKHR | AccessFlagBits2::eMicromapReadEXT | AccessFlagBits2::eMicromapWriteEXT | + AccessFlagBits2::eOpticalFlowReadNV | AccessFlagBits2::eOpticalFlowWriteNV; }; // wrapper class for enum VkSubmitFlagBits, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkSubmitFlagBits.html @@ -7411,6 +7426,28 @@ namespace VULKAN_HPP_NAMESPACE DeviceDiagnosticsConfigFlagBitsNV::eEnableAutomaticCheckpoints | DeviceDiagnosticsConfigFlagBitsNV::eEnableShaderErrorReporting; }; + //=== VK_QCOM_tile_shading === + + // wrapper class for enum VkTileShadingRenderPassFlagBitsQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileShadingRenderPassFlagBitsQCOM.html + enum class TileShadingRenderPassFlagBitsQCOM : VkTileShadingRenderPassFlagsQCOM + { + eEnable = VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM, + ePerTileExecution = VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM + }; + + // wrapper using for bitmask VkTileShadingRenderPassFlagsQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkTileShadingRenderPassFlagsQCOM.html + using TileShadingRenderPassFlagsQCOM = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR TileShadingRenderPassFlagsQCOM allFlags = + TileShadingRenderPassFlagBitsQCOM::eEnable | TileShadingRenderPassFlagBitsQCOM::ePerTileExecution; + }; + #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === @@ -8850,6 +8887,10 @@ namespace VULKAN_HPP_NAMESPACE case VULKAN_HPP_NAMESPACE::ObjectType::ePipelineBinaryKHR: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; + //=== VK_NV_external_compute_queue === + case VULKAN_HPP_NAMESPACE::ObjectType::eExternalComputeQueueNV: + return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; + //=== VK_EXT_device_generated_commands === case VULKAN_HPP_NAMESPACE::ObjectType::eIndirectCommandsLayoutEXT: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; case VULKAN_HPP_NAMESPACE::ObjectType::eIndirectExecutionSetEXT: return VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; diff --git a/include/vulkan/vulkan_extension_inspection.hpp b/include/vulkan/vulkan_extension_inspection.hpp index e6d24e3..dc82470 100644 --- a/include/vulkan/vulkan_extension_inspection.hpp +++ b/include/vulkan/vulkan_extension_inspection.hpp @@ -24,11 +24,13 @@ namespace VULKAN_HPP_NAMESPACE //=== Extension inspection functions === //====================================== - std::set const & getDeviceExtensions(); - std::set const & getInstanceExtensions(); - std::map const & getDeprecatedExtensions(); - std::map const & getObsoletedExtensions(); - std::map const & getPromotedExtensions(); + std::set const & getDeviceExtensions(); + std::set const & getInstanceExtensions(); + std::map const & getDeprecatedExtensions(); + std::map>> const & getExtensionDepends( std::string const & extension ); + std::pair> const &> getExtensionDepends( std::string const & version, std::string const & extension ); + std::map const & getObsoletedExtensions(); + std::map const & getPromotedExtensions(); VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & extension ); VULKAN_HPP_CONSTEXPR_20 std::string getExtensionObsoletedBy( std::string const & extension ); VULKAN_HPP_CONSTEXPR_20 std::string getExtensionPromotedTo( std::string const & extension ); @@ -309,6 +311,7 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) "VK_NV_cuda_kernel_launch", #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + "VK_QCOM_tile_shading", "VK_NV_low_latency", #if defined( VK_USE_PLATFORM_METAL_EXT ) "VK_EXT_metal_objects", @@ -448,6 +451,7 @@ namespace VULKAN_HPP_NAMESPACE "VK_NV_descriptor_pool_overallocation", "VK_KHR_video_encode_quantization_map", "VK_NV_raw_access_chains", + "VK_NV_external_compute_queue", "VK_KHR_shader_relaxed_extended_instruction", "VK_NV_command_buffer_inheritance", "VK_KHR_maintenance7", @@ -552,6 +556,2075 @@ namespace VULKAN_HPP_NAMESPACE return instanceExtensions; } + VULKAN_HPP_INLINE std::map>> const & getExtensionDepends( std::string const & extension ) + { + static const std::map>> noDependencies; + static const std::map>>> dependencies = { + { "VK_KHR_swapchain", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, + { "VK_KHR_display", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, + { "VK_KHR_display_swapchain", + { { "VK_VERSION_1_0", + { { + "VK_KHR_display", + "VK_KHR_swapchain", + } } } } }, +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + { "VK_KHR_xlib_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ +#if defined( VK_USE_PLATFORM_XCB_KHR ) + { "VK_KHR_xcb_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + { "VK_KHR_wayland_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + { "VK_KHR_android_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "VK_KHR_win32_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "VK_EXT_debug_marker", + { { "VK_VERSION_1_0", + { { + "VK_EXT_debug_report", + } } } } }, + { "VK_KHR_video_queue", + { { "VK_VERSION_1_1", + { { + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_KHR_video_decode_queue", + { { "VK_VERSION_1_0", + { { + "VK_KHR_synchronization2", + "VK_KHR_video_queue", + } } }, + { "VK_VERSION_1_3", + { { + "VK_KHR_video_queue", + } } } } }, + { "VK_EXT_transform_feedback", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_video_encode_h264", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_encode_queue", + } } } } }, + { "VK_KHR_video_encode_h265", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_encode_queue", + } } } } }, + { "VK_KHR_video_decode_h264", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_decode_queue", + } } } } }, + { "VK_AMD_texture_gather_bias_lod", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_dynamic_rendering", + { { "VK_VERSION_1_0", + { { + "VK_KHR_depth_stencil_resolve", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_depth_stencil_resolve", + } } }, + { "VK_VERSION_1_2", { {} } } } }, +#if defined( VK_USE_PLATFORM_GGP ) + { "VK_GGP_stream_descriptor_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, +#endif /*VK_USE_PLATFORM_GGP*/ + { "VK_NV_corner_sampled_image", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_multiview", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_external_memory", + { { "VK_VERSION_1_0", + { { + "VK_NV_external_memory_capabilities", + } } } } }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "VK_NV_external_memory_win32", + { { "VK_VERSION_1_0", + { { + "VK_NV_external_memory", + } } } } }, + { "VK_NV_win32_keyed_mutex", + { { "VK_VERSION_1_0", + { { + "VK_NV_external_memory_win32", + } } } } }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "VK_KHR_device_group", + { { "VK_VERSION_1_0", + { { + "VK_KHR_device_group_creation", + } } } } }, +#if defined( VK_USE_PLATFORM_VI_NN ) + { "VK_NN_vi_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, +#endif /*VK_USE_PLATFORM_VI_NN*/ + { "VK_EXT_texture_compression_astc_hdr", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_astc_decode_mode", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_pipeline_robustness", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_external_memory_capabilities", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_external_memory", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory_capabilities", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "VK_KHR_external_memory_win32", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "VK_KHR_external_memory_fd", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "VK_KHR_win32_keyed_mutex", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory_win32", + } } } } }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "VK_KHR_external_semaphore_capabilities", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_external_semaphore", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_semaphore_capabilities", + } } } } }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "VK_KHR_external_semaphore_win32", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_semaphore", + } } } } }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "VK_KHR_external_semaphore_fd", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_semaphore", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_push_descriptor", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_conditional_rendering", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_float16_int8", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_16bit_storage", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_storage_buffer_storage_class", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_incremental_present", + { { "VK_VERSION_1_0", + { { + "VK_KHR_swapchain", + } } } } }, + { "VK_EXT_direct_mode_display", + { { "VK_VERSION_1_0", + { { + "VK_KHR_display", + } } } } }, +#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + { "VK_EXT_acquire_xlib_display", + { { "VK_VERSION_1_0", + { { + "VK_EXT_direct_mode_display", + } } } } }, +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + { "VK_EXT_display_surface_counter", + { { "VK_VERSION_1_0", + { { + "VK_KHR_display", + } } } } }, + { "VK_EXT_display_control", + { { "VK_VERSION_1_0", + { { + "VK_EXT_display_surface_counter", + "VK_KHR_swapchain", + } } } } }, + { "VK_GOOGLE_display_timing", + { { "VK_VERSION_1_0", + { { + "VK_KHR_swapchain", + } } } } }, + { "VK_NVX_multiview_per_view_attributes", + { { "VK_VERSION_1_0", + { { + "VK_KHR_multiview", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_discard_rectangles", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_conservative_rasterization", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_depth_clip_enable", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_swapchain_colorspace", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, + { "VK_EXT_hdr_metadata", + { { "VK_VERSION_1_0", + { { + "VK_KHR_swapchain", + } } } } }, + { "VK_KHR_imageless_framebuffer", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_image_format_list", + "VK_KHR_maintenance2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_image_format_list", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_KHR_create_renderpass2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_maintenance2", + "VK_KHR_multiview", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_IMG_relaxed_line_rasterization", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shared_presentable_image", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_get_surface_capabilities2", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_get_surface_capabilities2", + "VK_KHR_swapchain", + } } } } }, + { "VK_KHR_external_fence_capabilities", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_external_fence", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_fence_capabilities", + } } } } }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "VK_KHR_external_fence_win32", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_fence", + } } } } }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "VK_KHR_external_fence_fd", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_fence", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_performance_query", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_get_surface_capabilities2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, + { "VK_KHR_variable_pointers", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_storage_buffer_storage_class", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_get_display_properties2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_display", + } } } } }, +#if defined( VK_USE_PLATFORM_IOS_MVK ) + { "VK_MVK_ios_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + { "VK_MVK_macos_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + { "VK_EXT_external_memory_dma_buf", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory_fd", + } } } } }, + { "VK_EXT_queue_family_foreign", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_dedicated_allocation", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_memory_requirements2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + { "VK_ANDROID_external_memory_android_hardware_buffer", + { { "VK_VERSION_1_0", + { { + "VK_EXT_queue_family_foreign", + "VK_KHR_dedicated_allocation", + "VK_KHR_external_memory", + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_queue_family_foreign", + } } } } }, +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + { "VK_EXT_sampler_filter_minmax", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VK_AMDX_shader_enqueue", + { { "VK_VERSION_1_0", + { { + "VK_EXT_extended_dynamic_state", + "VK_KHR_maintenance5", + "VK_KHR_pipeline_library", + "VK_KHR_spirv_1_4", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", + { { + "VK_KHR_maintenance5", + "VK_KHR_pipeline_library", + } } } } }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "VK_EXT_inline_uniform_block", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_maintenance1", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_bfloat16", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_sample_locations", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_blend_operation_advanced", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_acceleration_structure", + { { "VK_VERSION_1_1", + { { + "VK_EXT_descriptor_indexing", + "VK_KHR_buffer_device_address", + "VK_KHR_deferred_host_operations", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_deferred_host_operations", + } } } } }, + { "VK_KHR_ray_tracing_pipeline", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + "VK_KHR_spirv_1_4", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_acceleration_structure", + } } } } }, + { "VK_KHR_ray_query", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + "VK_KHR_spirv_1_4", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_acceleration_structure", + } } } } }, + { "VK_NV_shader_sm_builtins", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_sampler_ycbcr_conversion", + { { "VK_VERSION_1_0", + { { + "VK_KHR_bind_memory2", + "VK_KHR_get_memory_requirements2", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_maintenance1", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_image_drm_format_modifier", + { { "VK_VERSION_1_0", + { { + "VK_KHR_bind_memory2", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_image_format_list", + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_image_format_list", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_EXT_descriptor_indexing", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_maintenance3", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VK_KHR_portability_subset", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "VK_NV_shading_rate_image", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_ray_tracing", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_memory_requirements2", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_representative_fragment_test", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_maintenance3", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_subgroup_extended_types", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_8bit_storage", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_storage_buffer_storage_class", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_external_memory_host", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_atomic_int64", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_clock", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_calibrated_timestamps", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_AMD_shader_core_properties", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_video_decode_h265", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_decode_queue", + } } } } }, + { "VK_KHR_global_priority", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_vertex_attribute_divisor", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#if defined( VK_USE_PLATFORM_GGP ) + { "VK_GGP_frame_token", + { { "VK_VERSION_1_0", + { { + "VK_GGP_stream_descriptor_surface", + "VK_KHR_swapchain", + } } } } }, +#endif /*VK_USE_PLATFORM_GGP*/ + { "VK_KHR_driver_properties", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_float_controls", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_shader_subgroup_partitioned", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_depth_stencil_resolve", + { { "VK_VERSION_1_0", + { { + "VK_KHR_create_renderpass2", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_KHR_swapchain_mutable_format", + { { "VK_VERSION_1_0", + { { + "VK_KHR_image_format_list", + "VK_KHR_maintenance2", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_image_format_list", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_swapchain", + } } } } }, + { "VK_NV_compute_shader_derivatives", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_mesh_shader", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_fragment_shader_barycentric", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_shader_image_footprint", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_scissor_exclusive", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_device_diagnostic_checkpoints", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_timeline_semaphore", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_INTEL_shader_integer_functions2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_vulkan_memory_model", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_pci_bus_info", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_AMD_display_native_hdr", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_get_surface_capabilities2", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_get_surface_capabilities2", + "VK_KHR_swapchain", + } } } } }, +#if defined( VK_USE_PLATFORM_FUCHSIA ) + { "VK_FUCHSIA_imagepipe_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + { "VK_KHR_shader_terminate_invocation", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#if defined( VK_USE_PLATFORM_METAL_EXT ) + { "VK_EXT_metal_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + { "VK_EXT_fragment_density_map", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_scalar_block_layout", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_subgroup_size_control", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_fragment_shading_rate", + { { "VK_VERSION_1_0", + { { + "VK_KHR_create_renderpass2", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_create_renderpass2", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_AMD_shader_core_properties2", + { { "VK_VERSION_1_0", + { { + "VK_AMD_shader_core_properties", + } } } } }, + { "VK_AMD_device_coherent_memory", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_dynamic_rendering_local_read", + { { "VK_VERSION_1_0", + { { + "VK_KHR_dynamic_rendering", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_shader_image_atomic_int64", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_quad_control", + { { "VK_VERSION_1_1", + { { + "VK_KHR_shader_maximal_reconvergence", + "VK_KHR_vulkan_memory_model", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_shader_maximal_reconvergence", + } } } } }, + { "VK_KHR_spirv_1_4", + { { "VK_VERSION_1_1", + { { + "VK_KHR_shader_float_controls", + } } } } }, + { "VK_EXT_memory_budget", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_memory_priority", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_surface_protected_capabilities", + { { "VK_VERSION_1_1", + { { + "VK_KHR_get_surface_capabilities2", + } } } } }, + { "VK_NV_dedicated_allocation_image_aliasing", + { { "VK_VERSION_1_0", + { { + "VK_KHR_dedicated_allocation", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_separate_depth_stencil_layouts", + { { "VK_VERSION_1_0", + { { + "VK_KHR_create_renderpass2", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_create_renderpass2", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_EXT_buffer_device_address", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_present_wait", + { { "VK_VERSION_1_0", + { { + "VK_KHR_present_id", + "VK_KHR_swapchain", + } } } } }, + { "VK_NV_cooperative_matrix", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_coverage_reduction_mode", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_NV_framebuffer_mixed_samples", + } } }, + { "VK_VERSION_1_1", + { { + "VK_NV_framebuffer_mixed_samples", + } } } } }, + { "VK_EXT_fragment_shader_interlock", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_ycbcr_image_arrays", + { { "VK_VERSION_1_0", + { { + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_uniform_buffer_standard_layout", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_provoking_vertex", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "VK_EXT_full_screen_exclusive", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_get_surface_capabilities2", + "VK_KHR_surface", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_get_surface_capabilities2", + "VK_KHR_surface", + "VK_KHR_swapchain", + } } } } }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + { "VK_EXT_headless_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, + { "VK_KHR_buffer_device_address", + { { "VK_VERSION_1_0", + { { + "VK_KHR_device_group", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_line_rasterization", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_shader_atomic_float", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_host_query_reset", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_index_type_uint8", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_extended_dynamic_state", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_pipeline_executable_properties", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_host_image_copy", + { { "VK_VERSION_1_0", + { { + "VK_KHR_copy_commands2", + "VK_KHR_format_feature_flags2", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_copy_commands2", + "VK_KHR_format_feature_flags2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_map_memory_placed", + { { "VK_VERSION_1_0", + { { + "VK_KHR_map_memory2", + } } }, + { "VK_VERSION_1_4", { {} } } } }, + { "VK_EXT_shader_atomic_float2", + { { "VK_VERSION_1_0", + { { + "VK_EXT_shader_atomic_float", + } } } } }, + { "VK_EXT_surface_maintenance1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_surface_capabilities2", + "VK_KHR_surface", + } } } } }, + { "VK_EXT_swapchain_maintenance1", + { { "VK_VERSION_1_0", + { { + "VK_EXT_surface_maintenance1", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_surface_maintenance1", + "VK_KHR_swapchain", + } } } } }, + { "VK_EXT_shader_demote_to_helper_invocation", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_device_generated_commands", + { { "VK_VERSION_1_1", + { { + "VK_KHR_buffer_device_address", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_NV_inherited_viewport_scissor", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_integer_dot_product", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_texel_buffer_alignment", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_depth_bias_control", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_device_memory_report", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_acquire_drm_display", + { { "VK_VERSION_1_0", + { { + "VK_EXT_direct_mode_display", + } } } } }, + { "VK_EXT_robustness2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_custom_border_color", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_present_barrier", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_get_surface_capabilities2", + "VK_KHR_surface", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_get_surface_capabilities2", + "VK_KHR_surface", + "VK_KHR_swapchain", + } } } } }, + { "VK_KHR_present_id", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_private_data", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_pipeline_creation_cache_control", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_video_encode_queue", + { { "VK_VERSION_1_0", + { { + "VK_KHR_synchronization2", + "VK_KHR_video_queue", + } } }, + { "VK_VERSION_1_3", + { { + "VK_KHR_video_queue", + } } } } }, + { "VK_NV_device_diagnostics_config", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_QCOM_tile_shading", + { { "VK_VERSION_1_0", + { { + "VK_QCOM_tile_properties", + }, + { + "VK_KHR_get_physical_device_properties2", + } } } } }, + { "VK_KHR_synchronization2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_descriptor_buffer", + { { "VK_VERSION_1_0", + { { + "VK_EXT_descriptor_indexing", + "VK_KHR_buffer_device_address", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_descriptor_indexing", + "VK_KHR_buffer_device_address", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_graphics_pipeline_library", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_pipeline_library", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_pipeline_library", + } } } } }, + { "VK_AMD_shader_early_and_late_fragment_tests", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_fragment_shader_barycentric", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_subgroup_uniform_control_flow", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_zero_initialize_workgroup_memory", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_fragment_shading_rate_enums", + { { "VK_VERSION_1_0", + { { + "VK_KHR_fragment_shading_rate", + } } } } }, + { "VK_NV_ray_tracing_motion_blur", + { { "VK_VERSION_1_0", + { { + "VK_KHR_ray_tracing_pipeline", + } } } } }, + { "VK_EXT_mesh_shader", + { { "VK_VERSION_1_0", + { { + "VK_KHR_spirv_1_4", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_EXT_ycbcr_2plane_444_formats", + { { "VK_VERSION_1_0", + { { + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_fragment_density_map2", + { { "VK_VERSION_1_0", + { { + "VK_EXT_fragment_density_map", + } } } } }, + { "VK_QCOM_rotated_copy_commands", + { { "VK_VERSION_1_0", + { { + "VK_KHR_copy_commands2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_image_robustness", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_workgroup_memory_explicit_layout", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_copy_commands2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_image_compression_control", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_attachment_feedback_loop_layout", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_4444_formats", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_device_fault", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_ARM_rasterization_order_attachment_access", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_rgba10x6_formats", + { { "VK_VERSION_1_0", + { { + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + { "VK_NV_acquire_winrt_display", + { { "VK_VERSION_1_0", + { { + "VK_EXT_direct_mode_display", + } } } } }, +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + { "VK_EXT_directfb_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ + { "VK_VALVE_mutable_descriptor_type", + { { "VK_VERSION_1_0", + { { + "VK_KHR_maintenance3", + } } } } }, + { "VK_EXT_vertex_input_dynamic_state", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_physical_device_drm", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_device_address_binding_report", + { { "VK_VERSION_1_0", + { { + "VK_EXT_debug_utils", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_debug_utils", + } } } } }, + { "VK_EXT_depth_clip_control", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_primitive_topology_list_restart", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_format_feature_flags2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_present_mode_fifo_latest_ready", + { { "VK_VERSION_1_0", + { { + "VK_KHR_swapchain", + } } } } }, +#if defined( VK_USE_PLATFORM_FUCHSIA ) + { "VK_FUCHSIA_external_memory", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + "VK_KHR_external_memory_capabilities", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_FUCHSIA_external_semaphore", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_semaphore", + "VK_KHR_external_semaphore_capabilities", + } } } } }, + { "VK_FUCHSIA_buffer_collection", + { { "VK_VERSION_1_0", + { { + "VK_FUCHSIA_external_memory", + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", + { { + "VK_FUCHSIA_external_memory", + } } } } }, +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + { "VK_HUAWEI_subpass_shading", + { { "VK_VERSION_1_0", + { { + "VK_KHR_create_renderpass2", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_HUAWEI_invocation_mask", + { { "VK_VERSION_1_0", + { { + "VK_KHR_ray_tracing_pipeline", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", + { { + "VK_KHR_ray_tracing_pipeline", + } } } } }, + { "VK_NV_external_memory_rdma", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_pipeline_properties", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_multisampled_render_to_single_sampled", + { { "VK_VERSION_1_0", + { { + "VK_KHR_create_renderpass2", + "VK_KHR_depth_stencil_resolve", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_EXT_extended_dynamic_state2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + { "VK_QNX_screen_surface", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + { "VK_EXT_color_write_enable", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_primitives_generated_query", + { { "VK_VERSION_1_0", + { { + "VK_EXT_transform_feedback", + } } } } }, + { "VK_KHR_ray_tracing_maintenance1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + } } } } }, + { "VK_EXT_global_priority_query", + { { "VK_VERSION_1_0", + { { + "VK_EXT_global_priority", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_global_priority", + } } } } }, + { "VK_EXT_image_view_min_lod", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_multi_draw", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_image_2d_view_of_3d", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_maintenance1", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_shader_tile_image", { { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_opacity_micromap", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", + { { + "VK_KHR_acceleration_structure", + } } } } }, +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + { "VK_NV_displacement_micromap", + { { "VK_VERSION_1_0", + { { + "VK_EXT_opacity_micromap", + } } } } }, +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + { "VK_HUAWEI_cluster_culling_shader", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_border_color_swizzle", + { { "VK_VERSION_1_0", + { { + "VK_EXT_custom_border_color", + } } } } }, + { "VK_EXT_pageable_device_local_memory", + { { "VK_VERSION_1_0", + { { + "VK_EXT_memory_priority", + } } } } }, + { "VK_KHR_maintenance4", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_ARM_shader_core_properties", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_ARM_scheduling_controls", + { { "VK_VERSION_1_0", + { { + "VK_ARM_shader_core_builtins", + } } } } }, + { "VK_EXT_image_sliced_view_of_3d", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_maintenance1", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_VALVE_descriptor_set_host_mapping", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_depth_clamp_zero_one", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_non_seamless_cube_map", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_ARM_render_pass_striped", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_QCOM_fragment_density_map_offset", + { { "VK_VERSION_1_0", + { { + "VK_EXT_fragment_density_map", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_fragment_density_map", + } } } } }, + { "VK_NV_copy_memory_indirect", + { { "VK_VERSION_1_0", + { { + "VK_KHR_buffer_device_address", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_buffer_device_address", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_NV_memory_decompression", + { { "VK_VERSION_1_0", + { { + "VK_KHR_buffer_device_address", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_buffer_device_address", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_NV_device_generated_commands_compute", + { { "VK_VERSION_1_0", + { { + "VK_NV_device_generated_commands", + } } } } }, + { "VK_NV_ray_tracing_linear_swept_spheres", + { { "VK_VERSION_1_0", + { { + "VK_KHR_ray_tracing_pipeline", + } } } } }, + { "VK_NV_linear_color_attachment", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_GOOGLE_surfaceless_query", + { { "VK_VERSION_1_0", + { { + "VK_KHR_surface", + } } } } }, + { "VK_KHR_shader_maximal_reconvergence", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_image_compression_control_swapchain", + { { "VK_VERSION_1_0", + { { + "VK_EXT_image_compression_control", + } } } } }, + { "VK_QCOM_image_processing", + { { "VK_VERSION_1_0", + { { + "VK_KHR_format_feature_flags2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_nested_command_buffer", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_external_memory_acquire_unmodified", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_extended_dynamic_state3", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_subpass_merge_feedback", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_shader_module_identifier", + { { "VK_VERSION_1_0", + { { + "VK_EXT_pipeline_creation_cache_control", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_pipeline_creation_cache_control", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_rasterization_order_attachment_access", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_optical_flow", + { { "VK_VERSION_1_0", + { { + "VK_KHR_format_feature_flags2", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_format_feature_flags2", + "VK_KHR_synchronization2", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_EXT_legacy_dithering", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_pipeline_protected_access", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + { "VK_ANDROID_external_format_resolve", + { { "VK_VERSION_1_0", + { { + "VK_ANDROID_external_memory_android_hardware_buffer", + } } } } }, +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + { "VK_KHR_maintenance5", + { { "VK_VERSION_1_1", + { { + "VK_KHR_dynamic_rendering", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_KHR_ray_tracing_position_fetch", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + } } } } }, + { "VK_EXT_shader_object", + { { "VK_VERSION_1_0", + { { + "VK_KHR_dynamic_rendering", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_dynamic_rendering", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_KHR_pipeline_binary", + { { "VK_VERSION_1_0", + { { + "VK_KHR_maintenance5", + } } }, + { "VK_VERSION_1_4", { {} } } } }, + { "VK_QCOM_tile_properties", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_SEC_amigo_profiling", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_QCOM_multiview_per_view_viewports", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_ray_tracing_invocation_reorder", + { { "VK_VERSION_1_0", + { { + "VK_KHR_ray_tracing_pipeline", + } } } } }, + { "VK_EXT_mutable_descriptor_type", + { { "VK_VERSION_1_0", + { { + "VK_KHR_maintenance3", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_legacy_vertex_attributes", + { { "VK_VERSION_1_0", + { { + "VK_EXT_vertex_input_dynamic_state", + } } } } }, + { "VK_ARM_shader_core_builtins", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_pipeline_library_group_handles", + { { "VK_VERSION_1_0", + { { + "VK_KHR_pipeline_library", + "VK_KHR_ray_tracing_pipeline", + } } } } }, + { "VK_EXT_dynamic_rendering_unused_attachments", + { { "VK_VERSION_1_0", + { { + "VK_KHR_dynamic_rendering", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_KHR_dynamic_rendering", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_NV_low_latency2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_timeline_semaphore", + } } }, + { "VK_VERSION_1_2", { {} } } } }, + { "VK_KHR_cooperative_matrix", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_compute_shader_derivatives", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_video_decode_av1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_decode_queue", + } } } } }, + { "VK_KHR_video_encode_av1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_encode_queue", + } } } } }, + { "VK_KHR_video_maintenance1", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_queue", + } } } } }, + { "VK_NV_per_stage_descriptor_set", + { { "VK_VERSION_1_0", + { { + "VK_KHR_maintenance6", + } } }, + { "VK_VERSION_1_4", { {} } } } }, + { "VK_QCOM_image_processing2", + { { "VK_VERSION_1_0", + { { + "VK_QCOM_image_processing", + } } } } }, + { "VK_QCOM_filter_cubic_weights", + { { "VK_VERSION_1_0", + { { + "VK_EXT_filter_cubic", + } } } } }, + { "VK_QCOM_filter_cubic_clamp", + { { "VK_VERSION_1_0", + { { + "VK_EXT_filter_cubic", + "VK_EXT_sampler_filter_minmax", + } } }, + { "VK_VERSION_1_2", + { { + "VK_EXT_filter_cubic", + } } } } }, + { "VK_EXT_attachment_feedback_loop_dynamic_state", + { { "VK_VERSION_1_0", + { { + "VK_EXT_attachment_feedback_loop_layout", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_attachment_feedback_loop_layout", + } } } } }, + { "VK_KHR_vertex_attribute_divisor", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_float_controls2", + { { "VK_VERSION_1_1", + { { + "VK_KHR_shader_float_controls", + } } } } }, +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + { "VK_QNX_external_memory_screen_buffer", + { { "VK_VERSION_1_0", + { { + "VK_EXT_queue_family_foreign", + "VK_KHR_dedicated_allocation", + "VK_KHR_external_memory", + "VK_KHR_sampler_ycbcr_conversion", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_queue_family_foreign", + } } } } }, +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + { "VK_MSFT_layered_driver", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_index_type_uint8", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_line_rasterization", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_calibrated_timestamps", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_shader_expect_assume", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_maintenance6", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_descriptor_pool_overallocation", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_display_stereo", + { { "VK_VERSION_1_0", + { { + "VK_KHR_display", + "VK_KHR_get_display_properties2", + } } } } }, + { "VK_KHR_video_encode_quantization_map", + { { "VK_VERSION_1_0", + { { + "VK_KHR_format_feature_flags2", + "VK_KHR_video_encode_queue", + } } }, + { "VK_VERSION_1_3", + { { + "VK_KHR_video_encode_queue", + } } } } }, + { "VK_KHR_maintenance7", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_NV_cluster_acceleration_structure", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + } } } } }, + { "VK_NV_partitioned_acceleration_structure", + { { "VK_VERSION_1_0", + { { + "VK_KHR_acceleration_structure", + } } } } }, + { "VK_EXT_device_generated_commands", + { { "VK_VERSION_1_0", + { { + "VK_KHR_buffer_device_address", + "VK_KHR_maintenance5", + } } }, + { "VK_VERSION_1_2", + { { + "VK_KHR_maintenance5", + } } }, + { "VK_VERSION_1_3", { {} } } } }, + { "VK_KHR_maintenance8", { { "VK_VERSION_1_1", { {} } } } }, + { "VK_MESA_image_alignment_control", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_depth_clamp_control", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_KHR_video_maintenance2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_video_queue", + } } } } }, + { "VK_HUAWEI_hdr_vivid", + { { "VK_VERSION_1_0", + { { + "VK_EXT_hdr_metadata", + "VK_KHR_get_physical_device_properties2", + "VK_KHR_swapchain", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_hdr_metadata", + "VK_KHR_swapchain", + } } } } }, + { "VK_NV_cooperative_matrix2", + { { "VK_VERSION_1_0", + { { + "VK_KHR_cooperative_matrix", + } } } } }, + { "VK_ARM_pipeline_opacity_micromap", + { { "VK_VERSION_1_0", + { { + "VK_EXT_opacity_micromap", + } } } } }, +#if defined( VK_USE_PLATFORM_METAL_EXT ) + { "VK_EXT_external_memory_metal", + { { "VK_VERSION_1_0", + { { + "VK_KHR_external_memory", + } } }, + { "VK_VERSION_1_1", { {} } } } }, +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + { "VK_KHR_depth_clamp_zero_one", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_vertex_attribute_robustness", + { { "VK_VERSION_1_0", + { { + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", { {} } } } }, + { "VK_EXT_fragment_density_map_offset", + { { "VK_VERSION_1_0", + { { + "VK_EXT_fragment_density_map", + "VK_KHR_create_renderpass2", + "VK_KHR_dynamic_rendering", + "VK_KHR_get_physical_device_properties2", + } } }, + { "VK_VERSION_1_1", + { { + "VK_EXT_fragment_density_map", + "VK_KHR_create_renderpass2", + "VK_KHR_dynamic_rendering", + } } }, + { "VK_VERSION_1_2", + { { + "VK_EXT_fragment_density_map", + "VK_KHR_dynamic_rendering", + } } }, + { "VK_VERSION_1_3", + { { + "VK_EXT_fragment_density_map", + } } } } } + }; + auto depIt = dependencies.find( extension ); + return ( depIt != dependencies.end() ) ? depIt->second : noDependencies; + } + + VULKAN_HPP_INLINE std::pair> const &> getExtensionDepends( std::string const & version, + std::string const & extension ) + { +#if !defined( NDEBUG ) + static std::set versions = { "VK_VERSION_1_0", "VK_VERSION_1_1", "VK_VERSION_1_2", "VK_VERSION_1_3", "VK_VERSION_1_4" }; + assert( versions.find( version ) != versions.end() ); +#endif + static std::vector> noDependencies; + + std::map>> const & dependencies = getExtensionDepends( extension ); + if ( dependencies.empty() ) + { + return { true, noDependencies }; + } + auto depIt = dependencies.lower_bound( version ); + if ( ( depIt == dependencies.end() ) || ( depIt->first != version ) ) + { + depIt = std::prev( depIt ); + } + if ( depIt == dependencies.end() ) + { + return { false, noDependencies }; + } + else + { + return { true, depIt->second }; + } + } + VULKAN_HPP_INLINE std::map const & getObsoletedExtensions() { static const std::map obsoletedExtensions = { { "VK_AMD_negative_viewport_height", "VK_KHR_maintenance1" } }; @@ -1312,7 +3385,7 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) || ( extension == "VK_NV_cuda_kernel_launch" ) #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - || ( extension == "VK_NV_low_latency" ) + || ( extension == "VK_QCOM_tile_shading" ) || ( extension == "VK_NV_low_latency" ) #if defined( VK_USE_PLATFORM_METAL_EXT ) || ( extension == "VK_EXT_metal_objects" ) #endif /*VK_USE_PLATFORM_METAL_EXT*/ @@ -1384,12 +3457,13 @@ namespace VULKAN_HPP_NAMESPACE || ( extension == "VK_MSFT_layered_driver" ) || ( extension == "VK_KHR_index_type_uint8" ) || ( extension == "VK_KHR_line_rasterization" ) || ( extension == "VK_KHR_calibrated_timestamps" ) || ( extension == "VK_KHR_shader_expect_assume" ) || ( extension == "VK_KHR_maintenance6" ) || ( extension == "VK_NV_descriptor_pool_overallocation" ) || ( extension == "VK_KHR_video_encode_quantization_map" ) || - ( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || - ( extension == "VK_NV_command_buffer_inheritance" ) || ( extension == "VK_KHR_maintenance7" ) || - ( extension == "VK_NV_shader_atomic_float16_vector" ) || ( extension == "VK_EXT_shader_replicated_composites" ) || - ( extension == "VK_NV_ray_tracing_validation" ) || ( extension == "VK_NV_cluster_acceleration_structure" ) || - ( extension == "VK_NV_partitioned_acceleration_structure" ) || ( extension == "VK_EXT_device_generated_commands" ) || - ( extension == "VK_KHR_maintenance8" ) || ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) || + ( extension == "VK_NV_raw_access_chains" ) || ( extension == "VK_NV_external_compute_queue" ) || + ( extension == "VK_KHR_shader_relaxed_extended_instruction" ) || ( extension == "VK_NV_command_buffer_inheritance" ) || + ( extension == "VK_KHR_maintenance7" ) || ( extension == "VK_NV_shader_atomic_float16_vector" ) || + ( extension == "VK_EXT_shader_replicated_composites" ) || ( extension == "VK_NV_ray_tracing_validation" ) || + ( extension == "VK_NV_cluster_acceleration_structure" ) || ( extension == "VK_NV_partitioned_acceleration_structure" ) || + ( extension == "VK_EXT_device_generated_commands" ) || ( extension == "VK_KHR_maintenance8" ) || + ( extension == "VK_MESA_image_alignment_control" ) || ( extension == "VK_EXT_depth_clamp_control" ) || ( extension == "VK_KHR_video_maintenance2" ) || ( extension == "VK_HUAWEI_hdr_vivid" ) || ( extension == "VK_NV_cooperative_matrix2" ) || ( extension == "VK_ARM_pipeline_opacity_micromap" ) #if defined( VK_USE_PLATFORM_METAL_EXT ) diff --git a/include/vulkan/vulkan_format_traits.hpp b/include/vulkan/vulkan_format_traits.hpp index 5224e6c..d5802f5 100644 --- a/include/vulkan/vulkan_format_traits.hpp +++ b/include/vulkan/vulkan_format_traits.hpp @@ -4662,7 +4662,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eB8G8R8A8Unorm: @@ -4725,7 +4725,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eA8B8G8R8UnormPack32: @@ -4785,7 +4785,7 @@ namespace VULKAN_HPP_NAMESPACE case VULKAN_HPP_NAMESPACE::Format::eA8B8G8R8SrgbPack32: switch ( component ) { - case 0: return "SRGB"; + case 0: return "UNORM"; case 1: return "SRGB"; case 2: return "SRGB"; case 3: return "SRGB"; @@ -5381,7 +5381,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eBc2UnormBlock: @@ -5399,7 +5399,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eBc3UnormBlock: @@ -5417,7 +5417,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eBc4UnormBlock: @@ -5477,7 +5477,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8UnormBlock: @@ -5511,7 +5511,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eEtc2R8G8B8A8UnormBlock: @@ -5529,7 +5529,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eEacR11UnormBlock: @@ -5573,7 +5573,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eAstc5x4UnormBlock: @@ -5591,7 +5591,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eAstc5x5UnormBlock: @@ -5609,7 +5609,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eAstc6x5UnormBlock: @@ -5627,7 +5627,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eAstc6x6UnormBlock: @@ -5645,7 +5645,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eAstc8x5UnormBlock: @@ -5663,7 +5663,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eAstc8x6UnormBlock: @@ -5681,7 +5681,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eAstc8x8UnormBlock: @@ -5699,7 +5699,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eAstc10x5UnormBlock: @@ -5717,7 +5717,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eAstc10x6UnormBlock: @@ -5735,7 +5735,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eAstc10x8UnormBlock: @@ -5753,7 +5753,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eAstc10x10UnormBlock: @@ -5771,7 +5771,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eAstc12x10UnormBlock: @@ -5789,7 +5789,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eAstc12x12UnormBlock: @@ -5807,7 +5807,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eG8B8G8R8422Unorm: @@ -6319,7 +6319,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::ePvrtc14BppSrgbBlockIMG: @@ -6328,7 +6328,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::ePvrtc22BppSrgbBlockIMG: @@ -6337,7 +6337,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::ePvrtc24BppSrgbBlockIMG: @@ -6346,7 +6346,7 @@ namespace VULKAN_HPP_NAMESPACE case 0: return "SRGB"; case 1: return "SRGB"; case 2: return "SRGB"; - case 3: return "SRGB"; + case 3: return "UNORM"; default: VULKAN_HPP_ASSERT( false ); return ""; } case VULKAN_HPP_NAMESPACE::Format::eR16G16Sfixed5NV: diff --git a/include/vulkan/vulkan_funcs.hpp b/include/vulkan/vulkan_funcs.hpp index c770b89..bc34c7f 100644 --- a/include/vulkan/vulkan_funcs.hpp +++ b/include/vulkan/vulkan_funcs.hpp @@ -24930,6 +24930,66 @@ namespace VULKAN_HPP_NAMESPACE # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + + // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html + template + VULKAN_HPP_INLINE void CommandBuffer::dispatchTileQCOM( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdDispatchTileQCOM( static_cast( m_commandBuffer ) ); + } + + // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html + template + VULKAN_HPP_INLINE void CommandBuffer::beginPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM * pPerTileBeginInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBeginPerTileExecutionQCOM( static_cast( m_commandBuffer ), reinterpret_cast( pPerTileBeginInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html + template + VULKAN_HPP_INLINE void CommandBuffer::beginPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM & perTileBeginInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdBeginPerTileExecutionQCOM && "Function requires " ); +# endif + + d.vkCmdBeginPerTileExecutionQCOM( m_commandBuffer, reinterpret_cast( &perTileBeginInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html + template + VULKAN_HPP_INLINE void CommandBuffer::endPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM * pPerTileEndInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdEndPerTileExecutionQCOM( static_cast( m_commandBuffer ), reinterpret_cast( pPerTileEndInfo ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndPerTileExecutionQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html + template + VULKAN_HPP_INLINE void CommandBuffer::endPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM & perTileEndInfo, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCmdEndPerTileExecutionQCOM && "Function requires " ); +# endif + + d.vkCmdEndPerTileExecutionQCOM( m_commandBuffer, reinterpret_cast( &perTileEndInfo ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === @@ -30717,6 +30777,177 @@ namespace VULKAN_HPP_NAMESPACE } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_NV_external_compute_queue === + + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::createExternalComputeQueueNV( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV * pCreateInfo, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV * pExternalQueue, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateExternalComputeQueueNV( static_cast( m_device ), + reinterpret_cast( pCreateInfo ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pExternalQueue ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createExternalComputeQueueNV( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateExternalComputeQueueNV && "Function requires " ); +# endif + + VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue; + VULKAN_HPP_NAMESPACE::Result result = static_cast( d.vkCreateExternalComputeQueueNV( + m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( static_cast( allocator ) ), + reinterpret_cast( &externalQueue ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExternalComputeQueueNV" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( result, std::move( externalQueue ) ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createExternalComputeQueueNVUnique( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkCreateExternalComputeQueueNV && "Function requires " ); +# endif + + VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue; + VULKAN_HPP_NAMESPACE::Result result = static_cast( d.vkCreateExternalComputeQueueNV( + m_device, + reinterpret_cast( &createInfo ), + reinterpret_cast( static_cast( allocator ) ), + reinterpret_cast( &externalQueue ) ) ); + VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::Device::createExternalComputeQueueNVUnique" ); + + return VULKAN_HPP_NAMESPACE::detail::createResultValueType( + result, + UniqueHandle( externalQueue, detail::ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template + VULKAN_HPP_INLINE void Device::destroyExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyExternalComputeQueueNV( static_cast( m_device ), + static_cast( externalQueue ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template + VULKAN_HPP_INLINE void Device::destroyExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyExternalComputeQueueNV && "Function requires " ); +# endif + + d.vkDestroyExternalComputeQueueNV( + m_device, + static_cast( externalQueue ), + reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template + VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyExternalComputeQueueNV( static_cast( m_device ), + static_cast( externalQueue ), + reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template + VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkDestroyExternalComputeQueueNV && "Function requires " ); +# endif + + d.vkDestroyExternalComputeQueueNV( + m_device, + static_cast( externalQueue ), + reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkGetExternalComputeQueueDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html + template + VULKAN_HPP_INLINE void ExternalComputeQueueNV::getData( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV * params, + void * pData, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkGetExternalComputeQueueDataNV( + static_cast( m_externalComputeQueueNV ), reinterpret_cast( params ), pData ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetExternalComputeQueueDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair + ExternalComputeQueueNV::getData( Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# if ( VULKAN_HPP_DISPATCH_LOADER_DYNAMIC == 1 ) + VULKAN_HPP_ASSERT( d.vkGetExternalComputeQueueDataNV && "Function requires " ); +# endif + + std::pair data_; + VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV & arams = data_.first; + DataType & data = data_.second; + d.vkGetExternalComputeQueueDataNV( m_externalComputeQueueNV, reinterpret_cast( &arams ), &data ); + + return data_; + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_NV_cluster_acceleration_structure === // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see diff --git a/include/vulkan/vulkan_handles.hpp b/include/vulkan/vulkan_handles.hpp index 4deaa59..880948d 100644 --- a/include/vulkan/vulkan_handles.hpp +++ b/include/vulkan/vulkan_handles.hpp @@ -1350,6 +1350,14 @@ namespace VULKAN_HPP_NAMESPACE struct PhysicalDeviceCudaKernelLaunchPropertiesNV; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + struct PhysicalDeviceTileShadingFeaturesQCOM; + struct PhysicalDeviceTileShadingPropertiesQCOM; + struct RenderPassTileShadingCreateInfoQCOM; + struct PerTileBeginInfoQCOM; + struct PerTileEndInfoQCOM; + struct DispatchTileInfoQCOM; + //=== VK_NV_low_latency === struct QueryLowLatencySupportNV; @@ -1915,6 +1923,12 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_raw_access_chains === struct PhysicalDeviceRawAccessChainsFeaturesNV; + //=== VK_NV_external_compute_queue === + struct ExternalComputeQueueDeviceCreateInfoNV; + struct ExternalComputeQueueCreateInfoNV; + struct ExternalComputeQueueDataParamsNV; + struct PhysicalDeviceExternalComputeQueuePropertiesNV; + //=== VK_KHR_shader_relaxed_extended_instruction === struct PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR; @@ -2156,6 +2170,9 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_pipeline_binary === class PipelineBinaryKHR; + //=== VK_NV_external_compute_queue === + class ExternalComputeQueueNV; + //=== VK_EXT_device_generated_commands === class IndirectCommandsLayoutEXT; class IndirectExecutionSetEXT; @@ -2628,6 +2645,16 @@ namespace VULKAN_HPP_NAMESPACE using UniquePipelineBinaryKHR = UniqueHandle; + //=== VK_NV_external_compute_queue === + template + class UniqueHandleTraits + { + public: + using deleter = detail::ObjectDestroy; + }; + + using UniqueExternalComputeQueueNV = UniqueHandle; + //=== VK_EXT_device_generated_commands === template class UniqueHandleTraits @@ -6865,6 +6892,38 @@ namespace VULKAN_HPP_NAMESPACE # endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + + // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html + template + void dispatchTileQCOM( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html + template + void beginPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM * pPerTileBeginInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html + template + void beginPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM & perTileBeginInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkCmdEndPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html + template + void endPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM * pPerTileEndInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCmdEndPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html + template + void endPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM & perTileEndInfo, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_KHR_synchronization2 === // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html @@ -9083,6 +9142,110 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; + // wrapper class for handle VkExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueNV.html + class ExternalComputeQueueNV + { + public: + using CType = VkExternalComputeQueueNV; + using NativeType = VkExternalComputeQueueNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eExternalComputeQueueNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; + + public: + ExternalComputeQueueNV() VULKAN_HPP_NOEXCEPT {} // = default; - try to workaround a compiler issue + + ExternalComputeQueueNV( ExternalComputeQueueNV const & rhs ) = default; + ExternalComputeQueueNV & operator=( ExternalComputeQueueNV const & rhs ) = default; + +#if !defined( VULKAN_HPP_HANDLES_MOVE_EXCHANGE ) + ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) = default; + ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) = default; +#else + ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT + : m_externalComputeQueueNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_externalComputeQueueNV, {} ) ) + { + } + + ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT + { + m_externalComputeQueueNV = VULKAN_HPP_NAMESPACE::exchange( rhs.m_externalComputeQueueNV, {} ); + return *this; + } +#endif + + VULKAN_HPP_CONSTEXPR ExternalComputeQueueNV( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + + ExternalComputeQueueNV( VkExternalComputeQueueNV externalComputeQueueNV ) VULKAN_HPP_NOEXCEPT : m_externalComputeQueueNV( externalComputeQueueNV ) {} + + ExternalComputeQueueNV & operator=( VkExternalComputeQueueNV externalComputeQueueNV ) VULKAN_HPP_NOEXCEPT + { + m_externalComputeQueueNV = externalComputeQueueNV; + return *this; + } + + ExternalComputeQueueNV & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_externalComputeQueueNV = {}; + return *this; + } + + //=== VK_NV_external_compute_queue === + + // wrapper function for command vkGetExternalComputeQueueDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html + template + void getData( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV * params, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkGetExternalComputeQueueDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html + template + VULKAN_HPP_NODISCARD std::pair + getData( Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + operator VkExternalComputeQueueNV() const VULKAN_HPP_NOEXCEPT + { + return m_externalComputeQueueNV; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_externalComputeQueueNV != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_externalComputeQueueNV == VK_NULL_HANDLE; + } + + private: + VkExternalComputeQueueNV m_externalComputeQueueNV = {}; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV; + }; + +#if ( VK_USE_64_BIT_PTR_DEFINES == 1 ) + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV; + }; +#endif + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + // wrapper class for handle VkFramebuffer, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFramebuffer.html class Framebuffer { @@ -17180,6 +17343,64 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_NV_external_compute_queue === + + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + template + VULKAN_HPP_NODISCARD Result createExternalComputeQueueNV( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV * pCreateInfo, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV * pExternalQueue, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + template + VULKAN_HPP_NODISCARD typename ResultValueType::type + createExternalComputeQueueNV( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createExternalComputeQueueNVUnique( const VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template + void destroyExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template + void destroyExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue, + Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template + void destroy( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + // wrapper function for command vkDestroyExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkDestroyExternalComputeQueueNV.html + template + void destroy( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue, + Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_NV_cluster_acceleration_structure === // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see diff --git a/include/vulkan/vulkan_hash.hpp b/include/vulkan/vulkan_hash.hpp index 924d664..0b23f6a 100644 --- a/include/vulkan/vulkan_hash.hpp +++ b/include/vulkan/vulkan_hash.hpp @@ -536,6 +536,17 @@ namespace std } }; + //=== VK_NV_external_compute_queue === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV const & externalComputeQueueNV ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( externalComputeQueueNV ) ); + } + }; + //=== VK_EXT_device_generated_commands === template <> @@ -4512,6 +4523,18 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM const & dispatchTileInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, dispatchTileInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, dispatchTileInfoQCOM.pNext ); + return seed; + } + }; + template <> struct hash { @@ -5243,6 +5266,46 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV const & externalComputeQueueCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueCreateInfoNV.preferredQueue ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV const & externalComputeQueueDataParamsNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDataParamsNV.deviceIndex ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV const & externalComputeQueueDeviceCreateInfoNV ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, externalComputeQueueDeviceCreateInfoNV.reservedExternalQueues ); + return seed; + } + }; + template <> struct hash { @@ -8033,6 +8096,30 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM const & perTileBeginInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, perTileBeginInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, perTileBeginInfoQCOM.pNext ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM const & perTileEndInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, perTileEndInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, perTileEndInfoQCOM.pNext ); + return seed; + } + }; + template <> struct hash { @@ -9536,6 +9623,21 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV const & physicalDeviceExternalComputeQueuePropertiesNV ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.externalDataSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceExternalComputeQueuePropertiesNV.maxExternalQueues ); + return seed; + } + }; + template <> struct hash { @@ -13195,6 +13297,50 @@ namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingFeaturesQCOM const & physicalDeviceTileShadingFeaturesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShading ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingFragmentStage ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingColorAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingDepthAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingStencilAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingInputAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingSampledAttachments ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingPerTileDraw ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingPerTileDispatch ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingDispatchTile ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingApron ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingAnisotropicApron ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingAtomicOps ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingFeaturesQCOM.tileShadingImageProcessing ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM const & physicalDeviceTileShadingPropertiesQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.maxApronSize ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.preferNonCoherent ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.tileGranularity ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceTileShadingPropertiesQCOM.maxTileShadingRate ); + return seed; + } + }; + template <> struct hash { @@ -15662,6 +15808,20 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM const & renderPassTileShadingCreateInfoQCOM ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.sType ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.flags ); + VULKAN_HPP_HASH_COMBINE( seed, renderPassTileShadingCreateInfoQCOM.tileApronSize ); + return seed; + } + }; + template <> struct hash { diff --git a/include/vulkan/vulkan_raii.hpp b/include/vulkan/vulkan_raii.hpp index 88c21ed..8b57e77 100644 --- a/include/vulkan/vulkan_raii.hpp +++ b/include/vulkan/vulkan_raii.hpp @@ -1479,6 +1479,11 @@ namespace VULKAN_HPP_NAMESPACE vkCmdCudaLaunchKernelNV = PFN_vkCmdCudaLaunchKernelNV( vkGetDeviceProcAddr( device, "vkCmdCudaLaunchKernelNV" ) ); # endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + vkCmdDispatchTileQCOM = PFN_vkCmdDispatchTileQCOM( vkGetDeviceProcAddr( device, "vkCmdDispatchTileQCOM" ) ); + vkCmdBeginPerTileExecutionQCOM = PFN_vkCmdBeginPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdBeginPerTileExecutionQCOM" ) ); + vkCmdEndPerTileExecutionQCOM = PFN_vkCmdEndPerTileExecutionQCOM( vkGetDeviceProcAddr( device, "vkCmdEndPerTileExecutionQCOM" ) ); + # if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === vkExportMetalObjectsEXT = PFN_vkExportMetalObjectsEXT( vkGetDeviceProcAddr( device, "vkExportMetalObjectsEXT" ) ); @@ -1812,6 +1817,11 @@ namespace VULKAN_HPP_NAMESPACE vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT( vkGetDeviceProcAddr( device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT" ) ); + //=== VK_NV_external_compute_queue === + vkCreateExternalComputeQueueNV = PFN_vkCreateExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkCreateExternalComputeQueueNV" ) ); + vkDestroyExternalComputeQueueNV = PFN_vkDestroyExternalComputeQueueNV( vkGetDeviceProcAddr( device, "vkDestroyExternalComputeQueueNV" ) ); + vkGetExternalComputeQueueDataNV = PFN_vkGetExternalComputeQueueDataNV( vkGetDeviceProcAddr( device, "vkGetExternalComputeQueueDataNV" ) ); + //=== VK_NV_cluster_acceleration_structure === vkGetClusterAccelerationStructureBuildSizesNV = PFN_vkGetClusterAccelerationStructureBuildSizesNV( vkGetDeviceProcAddr( device, "vkGetClusterAccelerationStructureBuildSizesNV" ) ); @@ -2503,6 +2513,11 @@ namespace VULKAN_HPP_NAMESPACE PFN_dummy vkCmdCudaLaunchKernelNV_placeholder = 0; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + PFN_vkCmdDispatchTileQCOM vkCmdDispatchTileQCOM = 0; + PFN_vkCmdBeginPerTileExecutionQCOM vkCmdBeginPerTileExecutionQCOM = 0; + PFN_vkCmdEndPerTileExecutionQCOM vkCmdEndPerTileExecutionQCOM = 0; + # if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT = 0; @@ -2766,6 +2781,11 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkCmdSetDescriptorBufferOffsets2EXT vkCmdSetDescriptorBufferOffsets2EXT = 0; PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = 0; + //=== VK_NV_external_compute_queue === + PFN_vkCreateExternalComputeQueueNV vkCreateExternalComputeQueueNV = 0; + PFN_vkDestroyExternalComputeQueueNV vkDestroyExternalComputeQueueNV = 0; + PFN_vkGetExternalComputeQueueDataNV vkGetExternalComputeQueueDataNV = 0; + //=== VK_NV_cluster_acceleration_structure === PFN_vkGetClusterAccelerationStructureBuildSizesNV vkGetClusterAccelerationStructureBuildSizesNV = 0; PFN_vkCmdBuildClusterAccelerationStructureIndirectNV vkCmdBuildClusterAccelerationStructureIndirectNV = 0; @@ -2903,6 +2923,9 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_KHR_pipeline_binary === class PipelineBinaryKHR; + //=== VK_NV_external_compute_queue === + class ExternalComputeQueueNV; + //=== VK_EXT_device_generated_commands === class IndirectCommandsLayoutEXT; class IndirectExecutionSetEXT; @@ -5491,6 +5514,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD std::pair getCalibratedTimestampKHR( const VULKAN_HPP_NAMESPACE::CalibratedTimestampInfoKHR & timestampInfo ) const; + //=== VK_NV_external_compute_queue === + + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + VULKAN_HPP_NODISCARD + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::CreateReturnType::Type + createExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const + VULKAN_HPP_RAII_CREATE_NOEXCEPT; + //=== VK_NV_cluster_acceleration_structure === // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see @@ -5584,7 +5617,7 @@ namespace VULKAN_HPP_NAMESPACE VkAccelerationStructureKHR accelerationStructure, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_accelerationStructure( accelerationStructure ) + , m_accelerationStructureKHR( accelerationStructure ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -5602,7 +5635,7 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureKHR( AccelerationStructureKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_accelerationStructure( VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) ) + , m_accelerationStructureKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureKHR, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -5615,7 +5648,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_accelerationStructure, rhs.m_accelerationStructure ); + std::swap( m_accelerationStructureKHR, rhs.m_accelerationStructureKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -5624,26 +5657,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::AccelerationStructureKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_accelerationStructure; + return m_accelerationStructureKHR; } operator VULKAN_HPP_NAMESPACE::AccelerationStructureKHR() const VULKAN_HPP_NOEXCEPT { - return m_accelerationStructure; + return m_accelerationStructureKHR; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_accelerationStructure ) + if ( m_accelerationStructureKHR ) { getDispatcher()->vkDestroyAccelerationStructureKHR( static_cast( m_device ), - static_cast( m_accelerationStructure ), + static_cast( m_accelerationStructureKHR ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_accelerationStructure = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_accelerationStructureKHR = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::AccelerationStructureKHR release() @@ -5651,7 +5684,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_accelerationStructure, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_accelerationStructureKHR, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -5668,16 +5701,16 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureKHR & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_accelerationStructure, rhs.m_accelerationStructure ); + std::swap( m_accelerationStructureKHR, rhs.m_accelerationStructureKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::AccelerationStructureKHR m_accelerationStructure = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::AccelerationStructureKHR m_accelerationStructureKHR = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -5711,7 +5744,7 @@ namespace VULKAN_HPP_NAMESPACE VkAccelerationStructureNV accelerationStructure, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_accelerationStructure( accelerationStructure ) + , m_accelerationStructureNV( accelerationStructure ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -5729,7 +5762,7 @@ namespace VULKAN_HPP_NAMESPACE AccelerationStructureNV( AccelerationStructureNV && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_accelerationStructure( VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructure, {} ) ) + , m_accelerationStructureNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_accelerationStructureNV, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -5742,7 +5775,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_accelerationStructure, rhs.m_accelerationStructure ); + std::swap( m_accelerationStructureNV, rhs.m_accelerationStructureNV ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -5751,26 +5784,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::AccelerationStructureNV const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_accelerationStructure; + return m_accelerationStructureNV; } operator VULKAN_HPP_NAMESPACE::AccelerationStructureNV() const VULKAN_HPP_NOEXCEPT { - return m_accelerationStructure; + return m_accelerationStructureNV; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_accelerationStructure ) + if ( m_accelerationStructureNV ) { getDispatcher()->vkDestroyAccelerationStructureNV( static_cast( m_device ), - static_cast( m_accelerationStructure ), + static_cast( m_accelerationStructureNV ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_accelerationStructure = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_accelerationStructureNV = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::AccelerationStructureNV release() @@ -5778,7 +5811,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_accelerationStructure, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_accelerationStructureNV, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -5795,7 +5828,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::AccelerationStructureNV & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_accelerationStructure, rhs.m_accelerationStructure ); + std::swap( m_accelerationStructureNV, rhs.m_accelerationStructureNV ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -5813,10 +5846,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD DataType getHandle() const; private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::AccelerationStructureNV m_accelerationStructure = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::AccelerationStructureNV m_accelerationStructureNV = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -5986,7 +6019,7 @@ namespace VULKAN_HPP_NAMESPACE VkBufferCollectionFUCHSIA collection, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_collection( collection ) + , m_bufferCollectionFUCHSIA( collection ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -6004,7 +6037,7 @@ namespace VULKAN_HPP_NAMESPACE BufferCollectionFUCHSIA( BufferCollectionFUCHSIA && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_collection( VULKAN_HPP_NAMESPACE::exchange( rhs.m_collection, {} ) ) + , m_bufferCollectionFUCHSIA( VULKAN_HPP_NAMESPACE::exchange( rhs.m_bufferCollectionFUCHSIA, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -6017,7 +6050,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_collection, rhs.m_collection ); + std::swap( m_bufferCollectionFUCHSIA, rhs.m_bufferCollectionFUCHSIA ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -6026,26 +6059,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_collection; + return m_bufferCollectionFUCHSIA; } operator VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA() const VULKAN_HPP_NOEXCEPT { - return m_collection; + return m_bufferCollectionFUCHSIA; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_collection ) + if ( m_bufferCollectionFUCHSIA ) { getDispatcher()->vkDestroyBufferCollectionFUCHSIA( static_cast( m_device ), - static_cast( m_collection ), + static_cast( m_bufferCollectionFUCHSIA ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_collection = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_bufferCollectionFUCHSIA = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA release() @@ -6053,7 +6086,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_collection, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_bufferCollectionFUCHSIA, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -6070,7 +6103,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::BufferCollectionFUCHSIA & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_collection, rhs.m_collection ); + std::swap( m_bufferCollectionFUCHSIA, rhs.m_bufferCollectionFUCHSIA ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -6090,10 +6123,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA getProperties() const; private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA m_collection = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::BufferCollectionFUCHSIA m_bufferCollectionFUCHSIA = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -7414,6 +7447,19 @@ namespace VULKAN_HPP_NAMESPACE void cudaLaunchKernelNV( const VULKAN_HPP_NAMESPACE::CudaLaunchInfoNV & launchInfo ) const VULKAN_HPP_NOEXCEPT; # endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + + // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html + void dispatchTileQCOM() const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html + void beginPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM & perTileBeginInfo ) const VULKAN_HPP_NOEXCEPT; + + // wrapper function for command vkCmdEndPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html + void endPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM & perTileEndInfo ) const VULKAN_HPP_NOEXCEPT; + //=== VK_KHR_synchronization2 === // wrapper function for command vkCmdSetEvent2KHR, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdSetEvent2KHR.html @@ -7929,7 +7975,7 @@ namespace VULKAN_HPP_NAMESPACE VkCuFunctionNVX function, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_function( function ) + , m_cuFunctionNVX( function ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -7947,7 +7993,7 @@ namespace VULKAN_HPP_NAMESPACE CuFunctionNVX( CuFunctionNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_function( VULKAN_HPP_NAMESPACE::exchange( rhs.m_function, {} ) ) + , m_cuFunctionNVX( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuFunctionNVX, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -7960,7 +8006,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_function, rhs.m_function ); + std::swap( m_cuFunctionNVX, rhs.m_cuFunctionNVX ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -7969,25 +8015,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::CuFunctionNVX const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_function; + return m_cuFunctionNVX; } operator VULKAN_HPP_NAMESPACE::CuFunctionNVX() const VULKAN_HPP_NOEXCEPT { - return m_function; + return m_cuFunctionNVX; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_function ) + if ( m_cuFunctionNVX ) { - getDispatcher()->vkDestroyCuFunctionNVX( - static_cast( m_device ), static_cast( m_function ), reinterpret_cast( m_allocator ) ); + getDispatcher()->vkDestroyCuFunctionNVX( static_cast( m_device ), + static_cast( m_cuFunctionNVX ), + reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_function = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_cuFunctionNVX = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::CuFunctionNVX release() @@ -7995,7 +8042,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_function, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_cuFunctionNVX, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -8012,16 +8059,16 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuFunctionNVX & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_function, rhs.m_function ); + std::swap( m_cuFunctionNVX, rhs.m_cuFunctionNVX ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::CuFunctionNVX m_function = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CuFunctionNVX m_cuFunctionNVX = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -8055,7 +8102,7 @@ namespace VULKAN_HPP_NAMESPACE VkCuModuleNVX module, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_module( module ) + , m_cuModuleNVX( module ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -8073,7 +8120,7 @@ namespace VULKAN_HPP_NAMESPACE CuModuleNVX( CuModuleNVX && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_module( VULKAN_HPP_NAMESPACE::exchange( rhs.m_module, {} ) ) + , m_cuModuleNVX( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cuModuleNVX, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -8086,7 +8133,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_module, rhs.m_module ); + std::swap( m_cuModuleNVX, rhs.m_cuModuleNVX ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -8095,25 +8142,25 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::CuModuleNVX const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_module; + return m_cuModuleNVX; } operator VULKAN_HPP_NAMESPACE::CuModuleNVX() const VULKAN_HPP_NOEXCEPT { - return m_module; + return m_cuModuleNVX; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_module ) + if ( m_cuModuleNVX ) { getDispatcher()->vkDestroyCuModuleNVX( - static_cast( m_device ), static_cast( m_module ), reinterpret_cast( m_allocator ) ); + static_cast( m_device ), static_cast( m_cuModuleNVX ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_module = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_cuModuleNVX = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::CuModuleNVX release() @@ -8121,7 +8168,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_module, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_cuModuleNVX, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -8138,16 +8185,16 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CuModuleNVX & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_module, rhs.m_module ); + std::swap( m_cuModuleNVX, rhs.m_cuModuleNVX ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::CuModuleNVX m_module = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CuModuleNVX m_cuModuleNVX = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -8182,7 +8229,7 @@ namespace VULKAN_HPP_NAMESPACE VkCudaFunctionNV function, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_function( function ) + , m_cudaFunctionNV( function ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -8200,7 +8247,7 @@ namespace VULKAN_HPP_NAMESPACE CudaFunctionNV( CudaFunctionNV && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_function( VULKAN_HPP_NAMESPACE::exchange( rhs.m_function, {} ) ) + , m_cudaFunctionNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaFunctionNV, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -8213,7 +8260,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_function, rhs.m_function ); + std::swap( m_cudaFunctionNV, rhs.m_cudaFunctionNV ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -8222,25 +8269,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::CudaFunctionNV const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_function; + return m_cudaFunctionNV; } operator VULKAN_HPP_NAMESPACE::CudaFunctionNV() const VULKAN_HPP_NOEXCEPT { - return m_function; + return m_cudaFunctionNV; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_function ) + if ( m_cudaFunctionNV ) { - getDispatcher()->vkDestroyCudaFunctionNV( - static_cast( m_device ), static_cast( m_function ), reinterpret_cast( m_allocator ) ); + getDispatcher()->vkDestroyCudaFunctionNV( static_cast( m_device ), + static_cast( m_cudaFunctionNV ), + reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_function = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_cudaFunctionNV = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::CudaFunctionNV release() @@ -8248,7 +8296,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_function, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_cudaFunctionNV, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -8265,16 +8313,16 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaFunctionNV & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_function, rhs.m_function ); + std::swap( m_cudaFunctionNV, rhs.m_cudaFunctionNV ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::CudaFunctionNV m_function = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CudaFunctionNV m_cudaFunctionNV = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -8311,7 +8359,7 @@ namespace VULKAN_HPP_NAMESPACE VkCudaModuleNV module, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_module( module ) + , m_cudaModuleNV( module ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -8329,7 +8377,7 @@ namespace VULKAN_HPP_NAMESPACE CudaModuleNV( CudaModuleNV && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_module( VULKAN_HPP_NAMESPACE::exchange( rhs.m_module, {} ) ) + , m_cudaModuleNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_cudaModuleNV, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -8342,7 +8390,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_module, rhs.m_module ); + std::swap( m_cudaModuleNV, rhs.m_cudaModuleNV ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -8351,25 +8399,25 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::CudaModuleNV const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_module; + return m_cudaModuleNV; } operator VULKAN_HPP_NAMESPACE::CudaModuleNV() const VULKAN_HPP_NOEXCEPT { - return m_module; + return m_cudaModuleNV; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_module ) + if ( m_cudaModuleNV ) { getDispatcher()->vkDestroyCudaModuleNV( - static_cast( m_device ), static_cast( m_module ), reinterpret_cast( m_allocator ) ); + static_cast( m_device ), static_cast( m_cudaModuleNV ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_module = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_cudaModuleNV = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::CudaModuleNV release() @@ -8377,7 +8425,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_module, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_cudaModuleNV, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -8394,7 +8442,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::CudaModuleNV & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_module, rhs.m_module ); + std::swap( m_cudaModuleNV, rhs.m_cudaModuleNV ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -8405,10 +8453,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD std::vector getCache() const; private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::CudaModuleNV m_module = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::CudaModuleNV m_cudaModuleNV = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -8444,7 +8492,7 @@ namespace VULKAN_HPP_NAMESPACE VkDebugReportCallbackEXT callback, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_instance( instance ) - , m_callback( callback ) + , m_debugReportCallbackEXT( callback ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { @@ -8462,7 +8510,7 @@ namespace VULKAN_HPP_NAMESPACE DebugReportCallbackEXT( DebugReportCallbackEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) ) - , m_callback( VULKAN_HPP_NAMESPACE::exchange( rhs.m_callback, {} ) ) + , m_debugReportCallbackEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugReportCallbackEXT, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -8475,7 +8523,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_instance, rhs.m_instance ); - std::swap( m_callback, rhs.m_callback ); + std::swap( m_debugReportCallbackEXT, rhs.m_debugReportCallbackEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -8484,26 +8532,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_callback; + return m_debugReportCallbackEXT; } operator VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT() const VULKAN_HPP_NOEXCEPT { - return m_callback; + return m_debugReportCallbackEXT; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_callback ) + if ( m_debugReportCallbackEXT ) { getDispatcher()->vkDestroyDebugReportCallbackEXT( static_cast( m_instance ), - static_cast( m_callback ), + static_cast( m_debugReportCallbackEXT ), reinterpret_cast( m_allocator ) ); } - m_instance = nullptr; - m_callback = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_instance = nullptr; + m_debugReportCallbackEXT = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT release() @@ -8511,7 +8559,7 @@ namespace VULKAN_HPP_NAMESPACE m_instance = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_callback, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_debugReportCallbackEXT, nullptr ); } VULKAN_HPP_NAMESPACE::Instance getInstance() const @@ -8528,16 +8576,16 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugReportCallbackEXT & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_instance, rhs.m_instance ); - std::swap( m_callback, rhs.m_callback ); + std::swap( m_debugReportCallbackEXT, rhs.m_debugReportCallbackEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } private: - VULKAN_HPP_NAMESPACE::Instance m_instance = {}; - VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT m_callback = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::InstanceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Instance m_instance = {}; + VULKAN_HPP_NAMESPACE::DebugReportCallbackEXT m_debugReportCallbackEXT = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::InstanceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -8571,7 +8619,7 @@ namespace VULKAN_HPP_NAMESPACE VkDebugUtilsMessengerEXT messenger, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_instance( instance ) - , m_messenger( messenger ) + , m_debugUtilsMessengerEXT( messenger ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { @@ -8589,7 +8637,7 @@ namespace VULKAN_HPP_NAMESPACE DebugUtilsMessengerEXT( DebugUtilsMessengerEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) ) - , m_messenger( VULKAN_HPP_NAMESPACE::exchange( rhs.m_messenger, {} ) ) + , m_debugUtilsMessengerEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_debugUtilsMessengerEXT, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -8602,7 +8650,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_instance, rhs.m_instance ); - std::swap( m_messenger, rhs.m_messenger ); + std::swap( m_debugUtilsMessengerEXT, rhs.m_debugUtilsMessengerEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -8611,26 +8659,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_messenger; + return m_debugUtilsMessengerEXT; } operator VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT() const VULKAN_HPP_NOEXCEPT { - return m_messenger; + return m_debugUtilsMessengerEXT; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_messenger ) + if ( m_debugUtilsMessengerEXT ) { getDispatcher()->vkDestroyDebugUtilsMessengerEXT( static_cast( m_instance ), - static_cast( m_messenger ), + static_cast( m_debugUtilsMessengerEXT ), reinterpret_cast( m_allocator ) ); } - m_instance = nullptr; - m_messenger = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_instance = nullptr; + m_debugUtilsMessengerEXT = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT release() @@ -8638,7 +8686,7 @@ namespace VULKAN_HPP_NAMESPACE m_instance = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_messenger, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_debugUtilsMessengerEXT, nullptr ); } VULKAN_HPP_NAMESPACE::Instance getInstance() const @@ -8655,16 +8703,16 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DebugUtilsMessengerEXT & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_instance, rhs.m_instance ); - std::swap( m_messenger, rhs.m_messenger ); + std::swap( m_debugUtilsMessengerEXT, rhs.m_debugUtilsMessengerEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } private: - VULKAN_HPP_NAMESPACE::Instance m_instance = {}; - VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT m_messenger = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::InstanceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Instance m_instance = {}; + VULKAN_HPP_NAMESPACE::DebugUtilsMessengerEXT m_debugUtilsMessengerEXT = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::InstanceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -8697,7 +8745,7 @@ namespace VULKAN_HPP_NAMESPACE VkDeferredOperationKHR operation, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_operation( operation ) + , m_deferredOperationKHR( operation ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -8715,7 +8763,7 @@ namespace VULKAN_HPP_NAMESPACE DeferredOperationKHR( DeferredOperationKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_operation( VULKAN_HPP_NAMESPACE::exchange( rhs.m_operation, {} ) ) + , m_deferredOperationKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_deferredOperationKHR, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -8728,7 +8776,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_operation, rhs.m_operation ); + std::swap( m_deferredOperationKHR, rhs.m_deferredOperationKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -8737,26 +8785,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeferredOperationKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_operation; + return m_deferredOperationKHR; } operator VULKAN_HPP_NAMESPACE::DeferredOperationKHR() const VULKAN_HPP_NOEXCEPT { - return m_operation; + return m_deferredOperationKHR; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_operation ) + if ( m_deferredOperationKHR ) { getDispatcher()->vkDestroyDeferredOperationKHR( static_cast( m_device ), - static_cast( m_operation ), + static_cast( m_deferredOperationKHR ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_operation = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_deferredOperationKHR = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::DeferredOperationKHR release() @@ -8764,7 +8812,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_operation, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_deferredOperationKHR, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -8781,7 +8829,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeferredOperationKHR & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_operation, rhs.m_operation ); + std::swap( m_deferredOperationKHR, rhs.m_deferredOperationKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -8800,10 +8848,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::Result join() const; private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::DeferredOperationKHR m_operation = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DeferredOperationKHR m_deferredOperationKHR = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -9393,7 +9441,7 @@ namespace VULKAN_HPP_NAMESPACE VkDeviceMemory memory, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_memory( memory ) + , m_deviceMemory( memory ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -9411,7 +9459,7 @@ namespace VULKAN_HPP_NAMESPACE DeviceMemory( DeviceMemory && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_memory( VULKAN_HPP_NAMESPACE::exchange( rhs.m_memory, {} ) ) + , m_deviceMemory( VULKAN_HPP_NAMESPACE::exchange( rhs.m_deviceMemory, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -9424,7 +9472,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_memory, rhs.m_memory ); + std::swap( m_deviceMemory, rhs.m_deviceMemory ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -9433,25 +9481,25 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeviceMemory const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_memory; + return m_deviceMemory; } operator VULKAN_HPP_NAMESPACE::DeviceMemory() const VULKAN_HPP_NOEXCEPT { - return m_memory; + return m_deviceMemory; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_memory ) + if ( m_deviceMemory ) { getDispatcher()->vkFreeMemory( - static_cast( m_device ), static_cast( m_memory ), reinterpret_cast( m_allocator ) ); + static_cast( m_device ), static_cast( m_deviceMemory ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_memory = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_deviceMemory = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::DeviceMemory release() @@ -9459,7 +9507,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_memory, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_deviceMemory, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -9476,7 +9524,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceMemory & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_memory, rhs.m_memory ); + std::swap( m_deviceMemory, rhs.m_deviceMemory ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -9509,10 +9557,10 @@ namespace VULKAN_HPP_NAMESPACE void setPriorityEXT( float priority ) const VULKAN_HPP_NOEXCEPT; private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::DeviceMemory m_memory = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::DeviceMemory m_deviceMemory = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -9559,7 +9607,7 @@ namespace VULKAN_HPP_NAMESPACE # endif DisplayKHR( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PhysicalDevice const & physicalDevice, VkDisplayKHR display ) - : m_physicalDevice( physicalDevice ), m_display( display ), m_dispatcher( physicalDevice.getDispatcher() ) + : m_physicalDevice( physicalDevice ), m_displayKHR( display ), m_dispatcher( physicalDevice.getDispatcher() ) { } @@ -9575,7 +9623,7 @@ namespace VULKAN_HPP_NAMESPACE DisplayKHR( DisplayKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_physicalDevice( VULKAN_HPP_NAMESPACE::exchange( rhs.m_physicalDevice, {} ) ) - , m_display( VULKAN_HPP_NAMESPACE::exchange( rhs.m_display, {} ) ) + , m_displayKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_displayKHR, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { } @@ -9587,7 +9635,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_physicalDevice, rhs.m_physicalDevice ); - std::swap( m_display, rhs.m_display ); + std::swap( m_displayKHR, rhs.m_displayKHR ); std::swap( m_dispatcher, rhs.m_dispatcher ); } return *this; @@ -9595,22 +9643,22 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DisplayKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_display; + return m_displayKHR; } operator VULKAN_HPP_NAMESPACE::DisplayKHR() const VULKAN_HPP_NOEXCEPT { - return m_display; + return m_displayKHR; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_display ) + if ( m_displayKHR ) { - getDispatcher()->vkReleaseDisplayEXT( static_cast( m_physicalDevice ), static_cast( m_display ) ); + getDispatcher()->vkReleaseDisplayEXT( static_cast( m_physicalDevice ), static_cast( m_displayKHR ) ); } m_physicalDevice = nullptr; - m_display = nullptr; + m_displayKHR = nullptr; m_dispatcher = nullptr; } @@ -9618,7 +9666,7 @@ namespace VULKAN_HPP_NAMESPACE { m_physicalDevice = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_display, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_displayKHR, nullptr ); } VULKAN_HPP_NAMESPACE::PhysicalDevice getPhysicalDevice() const @@ -9635,7 +9683,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DisplayKHR & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_physicalDevice, rhs.m_physicalDevice ); - std::swap( m_display, rhs.m_display ); + std::swap( m_displayKHR, rhs.m_displayKHR ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -9671,7 +9719,7 @@ namespace VULKAN_HPP_NAMESPACE private: VULKAN_HPP_NAMESPACE::PhysicalDevice m_physicalDevice = {}; - VULKAN_HPP_NAMESPACE::DisplayKHR m_display = {}; + VULKAN_HPP_NAMESPACE::DisplayKHR m_displayKHR = {}; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::InstanceDispatcher const * m_dispatcher = nullptr; }; @@ -9960,6 +10008,140 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; + // wrapper class for handle VkExternalComputeQueueNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueNV.html + class ExternalComputeQueueNV + { + public: + using CType = VkExternalComputeQueueNV; + using CppType = VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV; + + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eExternalComputeQueueNV; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; + + public: +# if !defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) + ExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, + VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) + { + *this = device.createExternalComputeQueueNV( createInfo, allocator ); + } +# endif + + ExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, + VkExternalComputeQueueNV externalQueue, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) + : m_device( device ) + , m_externalComputeQueueNV( externalQueue ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + ExternalComputeQueueNV( std::nullptr_t ) {} + + ~ExternalComputeQueueNV() + { + clear(); + } + + ExternalComputeQueueNV() = delete; + ExternalComputeQueueNV( ExternalComputeQueueNV const & ) = delete; + + ExternalComputeQueueNV( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_externalComputeQueueNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_externalComputeQueueNV, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) + { + } + + ExternalComputeQueueNV & operator=( ExternalComputeQueueNV const & ) = delete; + + ExternalComputeQueueNV & operator=( ExternalComputeQueueNV && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + std::swap( m_device, rhs.m_device ); + std::swap( m_externalComputeQueueNV, rhs.m_externalComputeQueueNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV const & operator*() const VULKAN_HPP_NOEXCEPT + { + return m_externalComputeQueueNV; + } + + operator VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV() const VULKAN_HPP_NOEXCEPT + { + return m_externalComputeQueueNV; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_externalComputeQueueNV ) + { + getDispatcher()->vkDestroyExternalComputeQueueNV( static_cast( m_device ), + static_cast( m_externalComputeQueueNV ), + reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_externalComputeQueueNV = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return VULKAN_HPP_NAMESPACE::exchange( m_externalComputeQueueNV, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * getDispatcher() const + { + VULKAN_HPP_ASSERT( m_dispatcher->getVkHeaderVersion() == VK_HEADER_VERSION ); + return m_dispatcher; + } + + void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ExternalComputeQueueNV & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_externalComputeQueueNV, rhs.m_externalComputeQueueNV ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_NV_external_compute_queue === + + // wrapper function for command vkGetExternalComputeQueueDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html + template + VULKAN_HPP_NODISCARD std::pair getData() const VULKAN_HPP_NOEXCEPT; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV m_externalComputeQueueNV = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + template <> + struct isVulkanRAIIHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + // wrapper class for handle VkFence, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkFence.html class Fence { @@ -10587,7 +10769,7 @@ namespace VULKAN_HPP_NAMESPACE VkIndirectCommandsLayoutEXT indirectCommandsLayout, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_indirectCommandsLayout( indirectCommandsLayout ) + , m_indirectCommandsLayoutEXT( indirectCommandsLayout ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -10605,7 +10787,7 @@ namespace VULKAN_HPP_NAMESPACE IndirectCommandsLayoutEXT( IndirectCommandsLayoutEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_indirectCommandsLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectCommandsLayout, {} ) ) + , m_indirectCommandsLayoutEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutEXT, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -10618,7 +10800,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_indirectCommandsLayout, rhs.m_indirectCommandsLayout ); + std::swap( m_indirectCommandsLayoutEXT, rhs.m_indirectCommandsLayoutEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -10627,26 +10809,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_indirectCommandsLayout; + return m_indirectCommandsLayoutEXT; } operator VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT() const VULKAN_HPP_NOEXCEPT { - return m_indirectCommandsLayout; + return m_indirectCommandsLayoutEXT; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_indirectCommandsLayout ) + if ( m_indirectCommandsLayoutEXT ) { getDispatcher()->vkDestroyIndirectCommandsLayoutEXT( static_cast( m_device ), - static_cast( m_indirectCommandsLayout ), + static_cast( m_indirectCommandsLayoutEXT ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_indirectCommandsLayout = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_indirectCommandsLayoutEXT = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT release() @@ -10654,7 +10836,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_indirectCommandsLayout, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_indirectCommandsLayoutEXT, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -10671,16 +10853,16 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutEXT & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_indirectCommandsLayout, rhs.m_indirectCommandsLayout ); + std::swap( m_indirectCommandsLayoutEXT, rhs.m_indirectCommandsLayoutEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT m_indirectCommandsLayout = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutEXT m_indirectCommandsLayoutEXT = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -10714,7 +10896,7 @@ namespace VULKAN_HPP_NAMESPACE VkIndirectCommandsLayoutNV indirectCommandsLayout, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_indirectCommandsLayout( indirectCommandsLayout ) + , m_indirectCommandsLayoutNV( indirectCommandsLayout ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -10732,7 +10914,7 @@ namespace VULKAN_HPP_NAMESPACE IndirectCommandsLayoutNV( IndirectCommandsLayoutNV && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_indirectCommandsLayout( VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectCommandsLayout, {} ) ) + , m_indirectCommandsLayoutNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectCommandsLayoutNV, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -10745,7 +10927,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_indirectCommandsLayout, rhs.m_indirectCommandsLayout ); + std::swap( m_indirectCommandsLayoutNV, rhs.m_indirectCommandsLayoutNV ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -10754,26 +10936,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_indirectCommandsLayout; + return m_indirectCommandsLayoutNV; } operator VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV() const VULKAN_HPP_NOEXCEPT { - return m_indirectCommandsLayout; + return m_indirectCommandsLayoutNV; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_indirectCommandsLayout ) + if ( m_indirectCommandsLayoutNV ) { getDispatcher()->vkDestroyIndirectCommandsLayoutNV( static_cast( m_device ), - static_cast( m_indirectCommandsLayout ), + static_cast( m_indirectCommandsLayoutNV ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_indirectCommandsLayout = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_indirectCommandsLayoutNV = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV release() @@ -10781,7 +10963,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_indirectCommandsLayout, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_indirectCommandsLayoutNV, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -10798,16 +10980,16 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectCommandsLayoutNV & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_indirectCommandsLayout, rhs.m_indirectCommandsLayout ); + std::swap( m_indirectCommandsLayoutNV, rhs.m_indirectCommandsLayoutNV ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV m_indirectCommandsLayout = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::IndirectCommandsLayoutNV m_indirectCommandsLayoutNV = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -10841,7 +11023,7 @@ namespace VULKAN_HPP_NAMESPACE VkIndirectExecutionSetEXT indirectExecutionSet, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_indirectExecutionSet( indirectExecutionSet ) + , m_indirectExecutionSetEXT( indirectExecutionSet ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -10859,7 +11041,7 @@ namespace VULKAN_HPP_NAMESPACE IndirectExecutionSetEXT( IndirectExecutionSetEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_indirectExecutionSet( VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectExecutionSet, {} ) ) + , m_indirectExecutionSetEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_indirectExecutionSetEXT, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -10872,7 +11054,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_indirectExecutionSet, rhs.m_indirectExecutionSet ); + std::swap( m_indirectExecutionSetEXT, rhs.m_indirectExecutionSetEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -10881,26 +11063,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_indirectExecutionSet; + return m_indirectExecutionSetEXT; } operator VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT() const VULKAN_HPP_NOEXCEPT { - return m_indirectExecutionSet; + return m_indirectExecutionSetEXT; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_indirectExecutionSet ) + if ( m_indirectExecutionSetEXT ) { getDispatcher()->vkDestroyIndirectExecutionSetEXT( static_cast( m_device ), - static_cast( m_indirectExecutionSet ), + static_cast( m_indirectExecutionSetEXT ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_indirectExecutionSet = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_indirectExecutionSetEXT = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT release() @@ -10908,7 +11090,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_indirectExecutionSet, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_indirectExecutionSetEXT, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -10925,7 +11107,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::IndirectExecutionSetEXT & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_indirectExecutionSet, rhs.m_indirectExecutionSet ); + std::swap( m_indirectExecutionSetEXT, rhs.m_indirectExecutionSetEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -10943,10 +11125,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NOEXCEPT; private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT m_indirectExecutionSet = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::IndirectExecutionSetEXT m_indirectExecutionSetEXT = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -10980,7 +11162,7 @@ namespace VULKAN_HPP_NAMESPACE VkMicromapEXT micromap, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_micromap( micromap ) + , m_micromapEXT( micromap ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -10998,7 +11180,7 @@ namespace VULKAN_HPP_NAMESPACE MicromapEXT( MicromapEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_micromap( VULKAN_HPP_NAMESPACE::exchange( rhs.m_micromap, {} ) ) + , m_micromapEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_micromapEXT, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -11011,7 +11193,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_micromap, rhs.m_micromap ); + std::swap( m_micromapEXT, rhs.m_micromapEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -11020,25 +11202,25 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::MicromapEXT const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_micromap; + return m_micromapEXT; } operator VULKAN_HPP_NAMESPACE::MicromapEXT() const VULKAN_HPP_NOEXCEPT { - return m_micromap; + return m_micromapEXT; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_micromap ) + if ( m_micromapEXT ) { getDispatcher()->vkDestroyMicromapEXT( - static_cast( m_device ), static_cast( m_micromap ), reinterpret_cast( m_allocator ) ); + static_cast( m_device ), static_cast( m_micromapEXT ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_micromap = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_micromapEXT = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::MicromapEXT release() @@ -11046,7 +11228,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_micromap, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_micromapEXT, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -11063,16 +11245,16 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::MicromapEXT & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_micromap, rhs.m_micromap ); + std::swap( m_micromapEXT, rhs.m_micromapEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::MicromapEXT m_micromap = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::MicromapEXT m_micromapEXT = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -11106,7 +11288,7 @@ namespace VULKAN_HPP_NAMESPACE VkOpticalFlowSessionNV session, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_session( session ) + , m_opticalFlowSessionNV( session ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -11124,7 +11306,7 @@ namespace VULKAN_HPP_NAMESPACE OpticalFlowSessionNV( OpticalFlowSessionNV && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_session( VULKAN_HPP_NAMESPACE::exchange( rhs.m_session, {} ) ) + , m_opticalFlowSessionNV( VULKAN_HPP_NAMESPACE::exchange( rhs.m_opticalFlowSessionNV, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -11137,7 +11319,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_session, rhs.m_session ); + std::swap( m_opticalFlowSessionNV, rhs.m_opticalFlowSessionNV ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -11146,26 +11328,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_session; + return m_opticalFlowSessionNV; } operator VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV() const VULKAN_HPP_NOEXCEPT { - return m_session; + return m_opticalFlowSessionNV; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_session ) + if ( m_opticalFlowSessionNV ) { getDispatcher()->vkDestroyOpticalFlowSessionNV( static_cast( m_device ), - static_cast( m_session ), + static_cast( m_opticalFlowSessionNV ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_session = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_opticalFlowSessionNV = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV release() @@ -11173,7 +11355,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_session, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_opticalFlowSessionNV, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -11190,7 +11372,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::OpticalFlowSessionNV & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_session, rhs.m_session ); + std::swap( m_opticalFlowSessionNV, rhs.m_opticalFlowSessionNV ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -11204,10 +11386,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ImageLayout layout ) const; private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV m_session = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV m_opticalFlowSessionNV = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -11238,7 +11420,7 @@ namespace VULKAN_HPP_NAMESPACE # endif PerformanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, VkPerformanceConfigurationINTEL configuration ) - : m_device( device ), m_configuration( configuration ), m_dispatcher( device.getDispatcher() ) + : m_device( device ), m_performanceConfigurationINTEL( configuration ), m_dispatcher( device.getDispatcher() ) { } @@ -11254,7 +11436,7 @@ namespace VULKAN_HPP_NAMESPACE PerformanceConfigurationINTEL( PerformanceConfigurationINTEL && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_configuration( VULKAN_HPP_NAMESPACE::exchange( rhs.m_configuration, {} ) ) + , m_performanceConfigurationINTEL( VULKAN_HPP_NAMESPACE::exchange( rhs.m_performanceConfigurationINTEL, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { } @@ -11266,7 +11448,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_configuration, rhs.m_configuration ); + std::swap( m_performanceConfigurationINTEL, rhs.m_performanceConfigurationINTEL ); std::swap( m_dispatcher, rhs.m_dispatcher ); } return *this; @@ -11274,31 +11456,31 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_configuration; + return m_performanceConfigurationINTEL; } operator VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL() const VULKAN_HPP_NOEXCEPT { - return m_configuration; + return m_performanceConfigurationINTEL; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_configuration ) + if ( m_performanceConfigurationINTEL ) { getDispatcher()->vkReleasePerformanceConfigurationINTEL( static_cast( m_device ), - static_cast( m_configuration ) ); + static_cast( m_performanceConfigurationINTEL ) ); } - m_device = nullptr; - m_configuration = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_performanceConfigurationINTEL = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL release() { m_device = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_configuration, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_performanceConfigurationINTEL, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -11315,14 +11497,14 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PerformanceConfigurationINTEL & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_configuration, rhs.m_configuration ); + std::swap( m_performanceConfigurationINTEL, rhs.m_performanceConfigurationINTEL ); std::swap( m_dispatcher, rhs.m_dispatcher ); } private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL m_configuration = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::PerformanceConfigurationINTEL m_performanceConfigurationINTEL = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -11798,7 +11980,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Optional allocator = nullptr, VULKAN_HPP_NAMESPACE::Result successCode = VULKAN_HPP_NAMESPACE::Result::eSuccess ) : m_device( device ) - , m_pipelineBinary( pipelineBinary ) + , m_pipelineBinaryKHR( pipelineBinary ) , m_allocator( static_cast( allocator ) ) , m_constructorSuccessCode( successCode ) , m_dispatcher( device.getDispatcher() ) @@ -11817,7 +11999,7 @@ namespace VULKAN_HPP_NAMESPACE PipelineBinaryKHR( PipelineBinaryKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_pipelineBinary( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineBinary, {} ) ) + , m_pipelineBinaryKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_pipelineBinaryKHR, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_constructorSuccessCode( VULKAN_HPP_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) @@ -11831,7 +12013,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_pipelineBinary, rhs.m_pipelineBinary ); + std::swap( m_pipelineBinaryKHR, rhs.m_pipelineBinaryKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); std::swap( m_dispatcher, rhs.m_dispatcher ); @@ -11841,24 +12023,24 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::PipelineBinaryKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_pipelineBinary; + return m_pipelineBinaryKHR; } operator VULKAN_HPP_NAMESPACE::PipelineBinaryKHR() const VULKAN_HPP_NOEXCEPT { - return m_pipelineBinary; + return m_pipelineBinaryKHR; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_pipelineBinary ) + if ( m_pipelineBinaryKHR ) { getDispatcher()->vkDestroyPipelineBinaryKHR( static_cast( m_device ), - static_cast( m_pipelineBinary ), + static_cast( m_pipelineBinaryKHR ), reinterpret_cast( m_allocator ) ); } m_device = nullptr; - m_pipelineBinary = nullptr; + m_pipelineBinaryKHR = nullptr; m_allocator = nullptr; m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; m_dispatcher = nullptr; @@ -11870,7 +12052,7 @@ namespace VULKAN_HPP_NAMESPACE m_allocator = nullptr; m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_pipelineBinary, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_pipelineBinaryKHR, nullptr ); } VULKAN_HPP_NAMESPACE::Result getConstructorSuccessCode() const @@ -11892,7 +12074,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::PipelineBinaryKHR & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_pipelineBinary, rhs.m_pipelineBinary ); + std::swap( m_pipelineBinaryKHR, rhs.m_pipelineBinaryKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); std::swap( m_dispatcher, rhs.m_dispatcher ); @@ -11900,7 +12082,7 @@ namespace VULKAN_HPP_NAMESPACE private: VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::PipelineBinaryKHR m_pipelineBinary = {}; + VULKAN_HPP_NAMESPACE::PipelineBinaryKHR m_pipelineBinaryKHR = {}; const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; @@ -12818,7 +13000,7 @@ namespace VULKAN_HPP_NAMESPACE VkSamplerYcbcrConversion ycbcrConversion, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_ycbcrConversion( ycbcrConversion ) + , m_samplerYcbcrConversion( ycbcrConversion ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -12836,7 +13018,7 @@ namespace VULKAN_HPP_NAMESPACE SamplerYcbcrConversion( SamplerYcbcrConversion && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_ycbcrConversion( VULKAN_HPP_NAMESPACE::exchange( rhs.m_ycbcrConversion, {} ) ) + , m_samplerYcbcrConversion( VULKAN_HPP_NAMESPACE::exchange( rhs.m_samplerYcbcrConversion, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -12849,7 +13031,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_ycbcrConversion, rhs.m_ycbcrConversion ); + std::swap( m_samplerYcbcrConversion, rhs.m_samplerYcbcrConversion ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -12858,26 +13040,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_ycbcrConversion; + return m_samplerYcbcrConversion; } operator VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion() const VULKAN_HPP_NOEXCEPT { - return m_ycbcrConversion; + return m_samplerYcbcrConversion; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_ycbcrConversion ) + if ( m_samplerYcbcrConversion ) { getDispatcher()->vkDestroySamplerYcbcrConversion( static_cast( m_device ), - static_cast( m_ycbcrConversion ), + static_cast( m_samplerYcbcrConversion ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_ycbcrConversion = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_samplerYcbcrConversion = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion release() @@ -12885,7 +13067,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_ycbcrConversion, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_samplerYcbcrConversion, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -12902,16 +13084,16 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SamplerYcbcrConversion & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_ycbcrConversion, rhs.m_ycbcrConversion ); + std::swap( m_samplerYcbcrConversion, rhs.m_samplerYcbcrConversion ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion m_ycbcrConversion = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::SamplerYcbcrConversion m_samplerYcbcrConversion = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -13083,7 +13265,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Optional allocator = nullptr, VULKAN_HPP_NAMESPACE::Result successCode = VULKAN_HPP_NAMESPACE::Result::eSuccess ) : m_device( device ) - , m_shader( shader ) + , m_shaderEXT( shader ) , m_allocator( static_cast( allocator ) ) , m_constructorSuccessCode( successCode ) , m_dispatcher( device.getDispatcher() ) @@ -13102,7 +13284,7 @@ namespace VULKAN_HPP_NAMESPACE ShaderEXT( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_shader( VULKAN_HPP_NAMESPACE::exchange( rhs.m_shader, {} ) ) + , m_shaderEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_shaderEXT, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_constructorSuccessCode( VULKAN_HPP_NAMESPACE::exchange( rhs.m_constructorSuccessCode, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) @@ -13116,7 +13298,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_shader, rhs.m_shader ); + std::swap( m_shaderEXT, rhs.m_shaderEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); std::swap( m_dispatcher, rhs.m_dispatcher ); @@ -13126,23 +13308,23 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ShaderEXT const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_shader; + return m_shaderEXT; } operator VULKAN_HPP_NAMESPACE::ShaderEXT() const VULKAN_HPP_NOEXCEPT { - return m_shader; + return m_shaderEXT; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_shader ) + if ( m_shaderEXT ) { getDispatcher()->vkDestroyShaderEXT( - static_cast( m_device ), static_cast( m_shader ), reinterpret_cast( m_allocator ) ); + static_cast( m_device ), static_cast( m_shaderEXT ), reinterpret_cast( m_allocator ) ); } m_device = nullptr; - m_shader = nullptr; + m_shaderEXT = nullptr; m_allocator = nullptr; m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; m_dispatcher = nullptr; @@ -13154,7 +13336,7 @@ namespace VULKAN_HPP_NAMESPACE m_allocator = nullptr; m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_shader, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_shaderEXT, nullptr ); } VULKAN_HPP_NAMESPACE::Result getConstructorSuccessCode() const @@ -13176,7 +13358,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ShaderEXT & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_shader, rhs.m_shader ); + std::swap( m_shaderEXT, rhs.m_shaderEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_constructorSuccessCode, rhs.m_constructorSuccessCode ); std::swap( m_dispatcher, rhs.m_dispatcher ); @@ -13189,7 +13371,7 @@ namespace VULKAN_HPP_NAMESPACE private: VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::ShaderEXT m_shader = {}; + VULKAN_HPP_NAMESPACE::ShaderEXT m_shaderEXT = {}; const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; VULKAN_HPP_NAMESPACE::Result m_constructorSuccessCode = VULKAN_HPP_NAMESPACE::Result::eErrorUnknown; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; @@ -13537,7 +13719,7 @@ namespace VULKAN_HPP_NAMESPACE VkSurfaceKHR surface, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_instance( instance ) - , m_surface( surface ) + , m_surfaceKHR( surface ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( instance.getDispatcher() ) { @@ -13555,7 +13737,7 @@ namespace VULKAN_HPP_NAMESPACE SurfaceKHR( SurfaceKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_instance( VULKAN_HPP_NAMESPACE::exchange( rhs.m_instance, {} ) ) - , m_surface( VULKAN_HPP_NAMESPACE::exchange( rhs.m_surface, {} ) ) + , m_surfaceKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_surfaceKHR, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -13568,7 +13750,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_instance, rhs.m_instance ); - std::swap( m_surface, rhs.m_surface ); + std::swap( m_surfaceKHR, rhs.m_surfaceKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -13577,23 +13759,23 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::SurfaceKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_surface; + return m_surfaceKHR; } operator VULKAN_HPP_NAMESPACE::SurfaceKHR() const VULKAN_HPP_NOEXCEPT { - return m_surface; + return m_surfaceKHR; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_surface ) + if ( m_surfaceKHR ) { getDispatcher()->vkDestroySurfaceKHR( - static_cast( m_instance ), static_cast( m_surface ), reinterpret_cast( m_allocator ) ); + static_cast( m_instance ), static_cast( m_surfaceKHR ), reinterpret_cast( m_allocator ) ); } m_instance = nullptr; - m_surface = nullptr; + m_surfaceKHR = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; } @@ -13603,7 +13785,7 @@ namespace VULKAN_HPP_NAMESPACE m_instance = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_surface, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_surfaceKHR, nullptr ); } VULKAN_HPP_NAMESPACE::Instance getInstance() const @@ -13620,14 +13802,14 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SurfaceKHR & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_instance, rhs.m_instance ); - std::swap( m_surface, rhs.m_surface ); + std::swap( m_surfaceKHR, rhs.m_surfaceKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } private: VULKAN_HPP_NAMESPACE::Instance m_instance = {}; - VULKAN_HPP_NAMESPACE::SurfaceKHR m_surface = {}; + VULKAN_HPP_NAMESPACE::SurfaceKHR m_surfaceKHR = {}; const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::InstanceDispatcher const * m_dispatcher = nullptr; }; @@ -13663,7 +13845,7 @@ namespace VULKAN_HPP_NAMESPACE VkSwapchainKHR swapchain, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_swapchain( swapchain ) + , m_swapchainKHR( swapchain ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -13681,7 +13863,7 @@ namespace VULKAN_HPP_NAMESPACE SwapchainKHR( SwapchainKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_swapchain( VULKAN_HPP_NAMESPACE::exchange( rhs.m_swapchain, {} ) ) + , m_swapchainKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_swapchainKHR, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -13694,7 +13876,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_swapchain, rhs.m_swapchain ); + std::swap( m_swapchainKHR, rhs.m_swapchainKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -13703,25 +13885,25 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::SwapchainKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_swapchain; + return m_swapchainKHR; } operator VULKAN_HPP_NAMESPACE::SwapchainKHR() const VULKAN_HPP_NOEXCEPT { - return m_swapchain; + return m_swapchainKHR; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_swapchain ) + if ( m_swapchainKHR ) { getDispatcher()->vkDestroySwapchainKHR( - static_cast( m_device ), static_cast( m_swapchain ), reinterpret_cast( m_allocator ) ); + static_cast( m_device ), static_cast( m_swapchainKHR ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_swapchain = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_swapchainKHR = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::SwapchainKHR release() @@ -13729,7 +13911,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_swapchain, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_swapchainKHR, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -13746,7 +13928,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::SwapchainKHR & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_swapchain, rhs.m_swapchain ); + std::swap( m_swapchainKHR, rhs.m_swapchainKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -13819,10 +14001,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD std::vector getLatencyTimingsNV() const; private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchain = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::SwapchainKHR m_swapchainKHR = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -13883,7 +14065,7 @@ namespace VULKAN_HPP_NAMESPACE VkValidationCacheEXT validationCache, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_validationCache( validationCache ) + , m_validationCacheEXT( validationCache ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -13901,7 +14083,7 @@ namespace VULKAN_HPP_NAMESPACE ValidationCacheEXT( ValidationCacheEXT && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_validationCache( VULKAN_HPP_NAMESPACE::exchange( rhs.m_validationCache, {} ) ) + , m_validationCacheEXT( VULKAN_HPP_NAMESPACE::exchange( rhs.m_validationCacheEXT, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -13914,7 +14096,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_validationCache, rhs.m_validationCache ); + std::swap( m_validationCacheEXT, rhs.m_validationCacheEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -13923,26 +14105,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ValidationCacheEXT const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_validationCache; + return m_validationCacheEXT; } operator VULKAN_HPP_NAMESPACE::ValidationCacheEXT() const VULKAN_HPP_NOEXCEPT { - return m_validationCache; + return m_validationCacheEXT; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_validationCache ) + if ( m_validationCacheEXT ) { getDispatcher()->vkDestroyValidationCacheEXT( static_cast( m_device ), - static_cast( m_validationCache ), + static_cast( m_validationCacheEXT ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_validationCache = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_validationCacheEXT = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::ValidationCacheEXT release() @@ -13950,7 +14132,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_validationCache, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_validationCacheEXT, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -13967,7 +14149,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ValidationCacheEXT & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_validationCache, rhs.m_validationCache ); + std::swap( m_validationCacheEXT, rhs.m_validationCacheEXT ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -13982,10 +14164,10 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NODISCARD std::vector getData() const; private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::ValidationCacheEXT m_validationCache = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::ValidationCacheEXT m_validationCacheEXT = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -14019,7 +14201,7 @@ namespace VULKAN_HPP_NAMESPACE VkVideoSessionKHR videoSession, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_videoSession( videoSession ) + , m_videoSessionKHR( videoSession ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -14037,7 +14219,7 @@ namespace VULKAN_HPP_NAMESPACE VideoSessionKHR( VideoSessionKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_videoSession( VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSession, {} ) ) + , m_videoSessionKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionKHR, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -14050,7 +14232,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_videoSession, rhs.m_videoSession ); + std::swap( m_videoSessionKHR, rhs.m_videoSessionKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -14059,26 +14241,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VideoSessionKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_videoSession; + return m_videoSessionKHR; } operator VULKAN_HPP_NAMESPACE::VideoSessionKHR() const VULKAN_HPP_NOEXCEPT { - return m_videoSession; + return m_videoSessionKHR; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_videoSession ) + if ( m_videoSessionKHR ) { getDispatcher()->vkDestroyVideoSessionKHR( static_cast( m_device ), - static_cast( m_videoSession ), + static_cast( m_videoSessionKHR ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_videoSession = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_videoSessionKHR = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::VideoSessionKHR release() @@ -14086,7 +14268,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_videoSession, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_videoSessionKHR, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -14103,7 +14285,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionKHR & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_videoSession, rhs.m_videoSession ); + std::swap( m_videoSessionKHR, rhs.m_videoSessionKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -14119,10 +14301,10 @@ namespace VULKAN_HPP_NAMESPACE void bindMemory( VULKAN_HPP_NAMESPACE::ArrayProxy const & bindSessionMemoryInfos ) const; private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::VideoSessionKHR m_videoSession = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::VideoSessionKHR m_videoSessionKHR = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -14156,7 +14338,7 @@ namespace VULKAN_HPP_NAMESPACE VkVideoSessionParametersKHR videoSessionParameters, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) : m_device( device ) - , m_videoSessionParameters( videoSessionParameters ) + , m_videoSessionParametersKHR( videoSessionParameters ) , m_allocator( static_cast( allocator ) ) , m_dispatcher( device.getDispatcher() ) { @@ -14174,7 +14356,7 @@ namespace VULKAN_HPP_NAMESPACE VideoSessionParametersKHR( VideoSessionParametersKHR && rhs ) VULKAN_HPP_NOEXCEPT : m_device( VULKAN_HPP_NAMESPACE::exchange( rhs.m_device, {} ) ) - , m_videoSessionParameters( VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionParameters, {} ) ) + , m_videoSessionParametersKHR( VULKAN_HPP_NAMESPACE::exchange( rhs.m_videoSessionParametersKHR, {} ) ) , m_allocator( VULKAN_HPP_NAMESPACE::exchange( rhs.m_allocator, {} ) ) , m_dispatcher( VULKAN_HPP_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) { @@ -14187,7 +14369,7 @@ namespace VULKAN_HPP_NAMESPACE if ( this != &rhs ) { std::swap( m_device, rhs.m_device ); - std::swap( m_videoSessionParameters, rhs.m_videoSessionParameters ); + std::swap( m_videoSessionParametersKHR, rhs.m_videoSessionParametersKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -14196,26 +14378,26 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR const & operator*() const VULKAN_HPP_NOEXCEPT { - return m_videoSessionParameters; + return m_videoSessionParametersKHR; } operator VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR() const VULKAN_HPP_NOEXCEPT { - return m_videoSessionParameters; + return m_videoSessionParametersKHR; } void clear() VULKAN_HPP_NOEXCEPT { - if ( m_videoSessionParameters ) + if ( m_videoSessionParametersKHR ) { getDispatcher()->vkDestroyVideoSessionParametersKHR( static_cast( m_device ), - static_cast( m_videoSessionParameters ), + static_cast( m_videoSessionParametersKHR ), reinterpret_cast( m_allocator ) ); } - m_device = nullptr; - m_videoSessionParameters = nullptr; - m_allocator = nullptr; - m_dispatcher = nullptr; + m_device = nullptr; + m_videoSessionParametersKHR = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; } VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR release() @@ -14223,7 +14405,7 @@ namespace VULKAN_HPP_NAMESPACE m_device = nullptr; m_allocator = nullptr; m_dispatcher = nullptr; - return VULKAN_HPP_NAMESPACE::exchange( m_videoSessionParameters, nullptr ); + return VULKAN_HPP_NAMESPACE::exchange( m_videoSessionParametersKHR, nullptr ); } VULKAN_HPP_NAMESPACE::Device getDevice() const @@ -14240,7 +14422,7 @@ namespace VULKAN_HPP_NAMESPACE void swap( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::VideoSessionParametersKHR & rhs ) VULKAN_HPP_NOEXCEPT { std::swap( m_device, rhs.m_device ); - std::swap( m_videoSessionParameters, rhs.m_videoSessionParameters ); + std::swap( m_videoSessionParametersKHR, rhs.m_videoSessionParametersKHR ); std::swap( m_allocator, rhs.m_allocator ); std::swap( m_dispatcher, rhs.m_dispatcher ); } @@ -14252,10 +14434,10 @@ namespace VULKAN_HPP_NAMESPACE void update( const VULKAN_HPP_NAMESPACE::VideoSessionParametersUpdateInfoKHR & updateInfo ) const; private: - VULKAN_HPP_NAMESPACE::Device m_device = {}; - VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR m_videoSessionParameters = {}; - const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; - VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::VideoSessionParametersKHR m_videoSessionParametersKHR = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::DeviceDispatcher const * m_dispatcher = nullptr; }; template <> @@ -14720,12 +14902,13 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkMapMemory && "Function requires " ); void * pData; - VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkMapMemory( static_cast( m_device ), - static_cast( m_memory ), - static_cast( offset ), - static_cast( size ), - static_cast( flags ), - &pData ) ); + VULKAN_HPP_NAMESPACE::Result result = + static_cast( getDispatcher()->vkMapMemory( static_cast( m_device ), + static_cast( m_deviceMemory ), + static_cast( offset ), + static_cast( size ), + static_cast( flags ), + &pData ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::mapMemory" ); return pData; @@ -14736,7 +14919,7 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkUnmapMemory && "Function requires " ); - getDispatcher()->vkUnmapMemory( static_cast( m_device ), static_cast( m_memory ) ); + getDispatcher()->vkUnmapMemory( static_cast( m_device ), static_cast( m_deviceMemory ) ); } // wrapper function for command vkFlushMappedMemoryRanges, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkFlushMappedMemoryRanges.html @@ -14769,7 +14952,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DeviceSize committedMemoryInBytes; getDispatcher()->vkGetDeviceMemoryCommitment( - static_cast( m_device ), static_cast( m_memory ), reinterpret_cast( &committedMemoryInBytes ) ); + static_cast( m_device ), static_cast( m_deviceMemory ), reinterpret_cast( &committedMemoryInBytes ) ); return committedMemoryInBytes; } @@ -18049,13 +18232,13 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( getDispatcher()->vkGetSwapchainImagesKHR( - static_cast( m_device ), static_cast( m_swapchain ), &swapchainImageCount, nullptr ) ); + static_cast( m_device ), static_cast( m_swapchainKHR ), &swapchainImageCount, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && swapchainImageCount ) { swapchainImages.resize( swapchainImageCount ); result = static_cast( getDispatcher()->vkGetSwapchainImagesKHR( static_cast( m_device ), - static_cast( m_swapchain ), + static_cast( m_swapchainKHR ), &swapchainImageCount, reinterpret_cast( swapchainImages.data() ) ) ); } @@ -18078,7 +18261,7 @@ namespace VULKAN_HPP_NAMESPACE uint32_t imageIndex; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkAcquireNextImageKHR( static_cast( m_device ), - static_cast( m_swapchain ), + static_cast( m_swapchainKHR ), timeout, static_cast( semaphore ), static_cast( fence ), @@ -18302,13 +18485,13 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( getDispatcher()->vkGetDisplayModePropertiesKHR( - static_cast( m_physicalDevice ), static_cast( m_display ), &propertyCount, nullptr ) ); + static_cast( m_physicalDevice ), static_cast( m_displayKHR ), &propertyCount, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) { properties.resize( propertyCount ); result = static_cast( getDispatcher()->vkGetDisplayModePropertiesKHR( static_cast( m_physicalDevice ), - static_cast( m_display ), + static_cast( m_displayKHR ), &propertyCount, reinterpret_cast( properties.data() ) ) ); } @@ -18331,7 +18514,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::DisplayModeKHR mode; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkCreateDisplayModeKHR( static_cast( m_physicalDevice ), - static_cast( m_display ), + static_cast( m_displayKHR ), reinterpret_cast( &createInfo ), reinterpret_cast( static_cast( allocator ) ), reinterpret_cast( &mode ) ) ); @@ -18913,13 +19096,13 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( - static_cast( m_device ), static_cast( m_videoSession ), &memoryRequirementsCount, nullptr ) ); + static_cast( m_device ), static_cast( m_videoSessionKHR ), &memoryRequirementsCount, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && memoryRequirementsCount ) { memoryRequirements.resize( memoryRequirementsCount ); result = static_cast( getDispatcher()->vkGetVideoSessionMemoryRequirementsKHR( static_cast( m_device ), - static_cast( m_videoSession ), + static_cast( m_videoSessionKHR ), &memoryRequirementsCount, reinterpret_cast( memoryRequirements.data() ) ) ); } @@ -18941,7 +19124,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkBindVideoSessionMemoryKHR( static_cast( m_device ), - static_cast( m_videoSession ), + static_cast( m_videoSessionKHR ), bindSessionMemoryInfos.size(), reinterpret_cast( bindSessionMemoryInfos.data() ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionKHR::bindMemory" ); @@ -18982,7 +19165,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkUpdateVideoSessionParametersKHR( static_cast( m_device ), - static_cast( m_videoSessionParameters ), + static_cast( m_videoSessionParametersKHR ), reinterpret_cast( &updateInfo ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::VideoSessionParametersKHR::update" ); } @@ -19418,8 +19601,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkGetMemoryWin32HandleNV && "Function requires " ); HANDLE handle; - VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetMemoryWin32HandleNV( - static_cast( m_device ), static_cast( m_memory ), static_cast( handleType ), &handle ) ); + VULKAN_HPP_NAMESPACE::Result result = + static_cast( getDispatcher()->vkGetMemoryWin32HandleNV( static_cast( m_device ), + static_cast( m_deviceMemory ), + static_cast( handleType ), + &handle ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DeviceMemory::getMemoryWin32HandleNV" ); return handle; @@ -20218,8 +20404,11 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainCounterEXT && "Function requires " ); uint64_t counterValue; - VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetSwapchainCounterEXT( - static_cast( m_device ), static_cast( m_swapchain ), static_cast( counter ), &counterValue ) ); + VULKAN_HPP_NAMESPACE::Result result = + static_cast( getDispatcher()->vkGetSwapchainCounterEXT( static_cast( m_device ), + static_cast( m_swapchainKHR ), + static_cast( counter ), + &counterValue ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getCounterEXT" ); return counterValue; @@ -20236,7 +20425,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::RefreshCycleDurationGOOGLE displayTimingProperties; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetRefreshCycleDurationGOOGLE( static_cast( m_device ), - static_cast( m_swapchain ), + static_cast( m_swapchainKHR ), reinterpret_cast( &displayTimingProperties ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getRefreshCycleDurationGOOGLE" ); @@ -20256,13 +20445,13 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( getDispatcher()->vkGetPastPresentationTimingGOOGLE( - static_cast( m_device ), static_cast( m_swapchain ), &presentationTimingCount, nullptr ) ); + static_cast( m_device ), static_cast( m_swapchainKHR ), &presentationTimingCount, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && presentationTimingCount ) { presentationTimings.resize( presentationTimingCount ); result = static_cast( getDispatcher()->vkGetPastPresentationTimingGOOGLE( static_cast( m_device ), - static_cast( m_swapchain ), + static_cast( m_swapchainKHR ), &presentationTimingCount, reinterpret_cast( presentationTimings.data() ) ) ); } @@ -20401,7 +20590,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkGetSwapchainStatusKHR && "Function requires " ); VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkGetSwapchainStatusKHR( static_cast( m_device ), static_cast( m_swapchain ) ) ); + getDispatcher()->vkGetSwapchainStatusKHR( static_cast( m_device ), static_cast( m_swapchainKHR ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::getStatus", { VULKAN_HPP_NAMESPACE::Result::eSuccess, VULKAN_HPP_NAMESPACE::Result::eSuboptimalKHR } ); @@ -20757,13 +20946,13 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( getDispatcher()->vkGetDisplayModeProperties2KHR( - static_cast( m_physicalDevice ), static_cast( m_display ), &propertyCount, nullptr ) ); + static_cast( m_physicalDevice ), static_cast( m_displayKHR ), &propertyCount, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) { properties.resize( propertyCount ); result = static_cast( getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast( m_physicalDevice ), - static_cast( m_display ), + static_cast( m_displayKHR ), &propertyCount, reinterpret_cast( properties.data() ) ) ); } @@ -20792,7 +20981,7 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( getDispatcher()->vkGetDisplayModeProperties2KHR( - static_cast( m_physicalDevice ), static_cast( m_display ), &propertyCount, nullptr ) ); + static_cast( m_physicalDevice ), static_cast( m_displayKHR ), &propertyCount, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && propertyCount ) { structureChains.resize( propertyCount ); @@ -20803,7 +20992,7 @@ namespace VULKAN_HPP_NAMESPACE } result = static_cast( getDispatcher()->vkGetDisplayModeProperties2KHR( static_cast( m_physicalDevice ), - static_cast( m_display ), + static_cast( m_displayKHR ), &propertyCount, reinterpret_cast( properties.data() ) ) ); } @@ -22053,7 +22242,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkMergeValidationCachesEXT( static_cast( m_device ), - static_cast( m_validationCache ), + static_cast( m_validationCacheEXT ), srcCaches.size(), reinterpret_cast( srcCaches.data() ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::merge" ); @@ -22070,12 +22259,15 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( getDispatcher()->vkGetValidationCacheDataEXT( - static_cast( m_device ), static_cast( m_validationCache ), &dataSize, nullptr ) ); + static_cast( m_device ), static_cast( m_validationCacheEXT ), &dataSize, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) { data.resize( dataSize ); - result = static_cast( getDispatcher()->vkGetValidationCacheDataEXT( - static_cast( m_device ), static_cast( m_validationCache ), &dataSize, reinterpret_cast( data.data() ) ) ); + result = + static_cast( getDispatcher()->vkGetValidationCacheDataEXT( static_cast( m_device ), + static_cast( m_validationCacheEXT ), + &dataSize, + reinterpret_cast( data.data() ) ) ); } } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::ValidationCacheEXT::getData" ); @@ -22395,7 +22587,7 @@ namespace VULKAN_HPP_NAMESPACE std::vector data( dataSize / sizeof( DataType ) ); VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast( m_device ), - static_cast( m_accelerationStructure ), + static_cast( m_accelerationStructureNV ), data.size() * sizeof( DataType ), reinterpret_cast( data.data() ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" ); @@ -22413,7 +22605,7 @@ namespace VULKAN_HPP_NAMESPACE DataType data; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetAccelerationStructureHandleNV( static_cast( m_device ), - static_cast( m_accelerationStructure ), + static_cast( m_accelerationStructureNV ), sizeof( DataType ), reinterpret_cast( &data ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::AccelerationStructureNV::getHandle" ); @@ -22941,7 +23133,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkSetLocalDimmingAMD && "Function requires " ); getDispatcher()->vkSetLocalDimmingAMD( - static_cast( m_device ), static_cast( m_swapchain ), static_cast( localDimmingEnable ) ); + static_cast( m_device ), static_cast( m_swapchainKHR ), static_cast( localDimmingEnable ) ); } # if defined( VK_USE_PLATFORM_FUCHSIA ) @@ -23134,7 +23326,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkWaitForPresentKHR && "Function requires " ); VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkWaitForPresentKHR( static_cast( m_device ), static_cast( m_swapchain ), presentId, timeout ) ); + getDispatcher()->vkWaitForPresentKHR( static_cast( m_device ), static_cast( m_swapchainKHR ), presentId, timeout ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::waitForPresent", @@ -23259,7 +23451,7 @@ namespace VULKAN_HPP_NAMESPACE "Function requires " ); VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkAcquireFullScreenExclusiveModeEXT( static_cast( m_device ), static_cast( m_swapchain ) ) ); + getDispatcher()->vkAcquireFullScreenExclusiveModeEXT( static_cast( m_device ), static_cast( m_swapchainKHR ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::acquireFullScreenExclusiveModeEXT" ); } @@ -23271,7 +23463,7 @@ namespace VULKAN_HPP_NAMESPACE "Function requires " ); VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkReleaseFullScreenExclusiveModeEXT( static_cast( m_device ), static_cast( m_swapchain ) ) ); + getDispatcher()->vkReleaseFullScreenExclusiveModeEXT( static_cast( m_device ), static_cast( m_swapchainKHR ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::releaseFullScreenExclusiveModeEXT" ); } @@ -23576,8 +23768,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR && "Function requires " ); - uint32_t result = - getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR( static_cast( m_device ), static_cast( m_operation ) ); + uint32_t result = getDispatcher()->vkGetDeferredOperationMaxConcurrencyKHR( static_cast( m_device ), + static_cast( m_deferredOperationKHR ) ); return result; } @@ -23590,7 +23782,7 @@ namespace VULKAN_HPP_NAMESPACE "Function requires " ); VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkGetDeferredOperationResultKHR( static_cast( m_device ), static_cast( m_operation ) ) ); + getDispatcher()->vkGetDeferredOperationResultKHR( static_cast( m_device ), static_cast( m_deferredOperationKHR ) ) ); return static_cast( result ); } @@ -23601,7 +23793,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkDeferredOperationJoinKHR && "Function requires " ); VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkDeferredOperationJoinKHR( static_cast( m_device ), static_cast( m_operation ) ) ); + getDispatcher()->vkDeferredOperationJoinKHR( static_cast( m_device ), static_cast( m_deferredOperationKHR ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DeferredOperationKHR::join", @@ -24213,12 +24405,12 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( - getDispatcher()->vkGetCudaModuleCacheNV( static_cast( m_device ), static_cast( m_module ), &cacheSize, nullptr ) ); + getDispatcher()->vkGetCudaModuleCacheNV( static_cast( m_device ), static_cast( m_cudaModuleNV ), &cacheSize, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && cacheSize ) { cacheData.resize( cacheSize ); result = static_cast( getDispatcher()->vkGetCudaModuleCacheNV( - static_cast( m_device ), static_cast( m_module ), &cacheSize, reinterpret_cast( cacheData.data() ) ) ); + static_cast( m_device ), static_cast( m_cudaModuleNV ), &cacheSize, reinterpret_cast( cacheData.data() ) ) ); } } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::CudaModuleNV::getCache" ); @@ -24264,6 +24456,37 @@ namespace VULKAN_HPP_NAMESPACE } # endif /*VK_ENABLE_BETA_EXTENSIONS*/ + //=== VK_QCOM_tile_shading === + + // wrapper function for command vkCmdDispatchTileQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdDispatchTileQCOM.html + VULKAN_HPP_INLINE void CommandBuffer::dispatchTileQCOM() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdDispatchTileQCOM && "Function requires " ); + + getDispatcher()->vkCmdDispatchTileQCOM( static_cast( m_commandBuffer ) ); + } + + // wrapper function for command vkCmdBeginPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdBeginPerTileExecutionQCOM.html + VULKAN_HPP_INLINE void + CommandBuffer::beginPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM & perTileBeginInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBeginPerTileExecutionQCOM && "Function requires " ); + + getDispatcher()->vkCmdBeginPerTileExecutionQCOM( static_cast( m_commandBuffer ), + reinterpret_cast( &perTileBeginInfo ) ); + } + + // wrapper function for command vkCmdEndPerTileExecutionQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCmdEndPerTileExecutionQCOM.html + VULKAN_HPP_INLINE void CommandBuffer::endPerTileExecutionQCOM( const VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM & perTileEndInfo ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdEndPerTileExecutionQCOM && "Function requires " ); + + getDispatcher()->vkCmdEndPerTileExecutionQCOM( static_cast( m_commandBuffer ), + reinterpret_cast( &perTileEndInfo ) ); + } + # if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === @@ -24703,7 +24926,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkAcquireWinrtDisplayNV && "Function requires " ); VULKAN_HPP_NAMESPACE::Result result = static_cast( - getDispatcher()->vkAcquireWinrtDisplayNV( static_cast( m_physicalDevice ), static_cast( m_display ) ) ); + getDispatcher()->vkAcquireWinrtDisplayNV( static_cast( m_physicalDevice ), static_cast( m_displayKHR ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::DisplayKHR::acquireWinrtNV" ); } @@ -24899,7 +25122,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkSetBufferCollectionImageConstraintsFUCHSIA( static_cast( m_device ), - static_cast( m_collection ), + static_cast( m_bufferCollectionFUCHSIA ), reinterpret_cast( &imageConstraintsInfo ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setImageConstraints" ); } @@ -24914,7 +25137,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkSetBufferCollectionBufferConstraintsFUCHSIA( static_cast( m_device ), - static_cast( m_collection ), + static_cast( m_bufferCollectionFUCHSIA ), reinterpret_cast( &bufferConstraintsInfo ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::setBufferConstraints" ); } @@ -24929,7 +25152,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::BufferCollectionPropertiesFUCHSIA properties; VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkGetBufferCollectionPropertiesFUCHSIA( static_cast( m_device ), - static_cast( m_collection ), + static_cast( m_bufferCollectionFUCHSIA ), reinterpret_cast( &properties ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::BufferCollectionFUCHSIA::getProperties" ); @@ -25441,7 +25664,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkSetDeviceMemoryPriorityEXT && "Function requires " ); - getDispatcher()->vkSetDeviceMemoryPriorityEXT( static_cast( m_device ), static_cast( m_memory ), priority ); + getDispatcher()->vkSetDeviceMemoryPriorityEXT( static_cast( m_device ), static_cast( m_deviceMemory ), priority ); } //=== VK_KHR_maintenance4 === @@ -26160,7 +26383,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkBindOpticalFlowSessionImageNV( static_cast( m_device ), - static_cast( m_session ), + static_cast( m_opticalFlowSessionNV ), static_cast( bindingPoint ), static_cast( view ), static_cast( layout ) ) ); @@ -26363,12 +26586,12 @@ namespace VULKAN_HPP_NAMESPACE do { result = static_cast( - getDispatcher()->vkGetShaderBinaryDataEXT( static_cast( m_device ), static_cast( m_shader ), &dataSize, nullptr ) ); + getDispatcher()->vkGetShaderBinaryDataEXT( static_cast( m_device ), static_cast( m_shaderEXT ), &dataSize, nullptr ) ); if ( ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) && dataSize ) { data.resize( dataSize ); result = static_cast( getDispatcher()->vkGetShaderBinaryDataEXT( - static_cast( m_device ), static_cast( m_shader ), &dataSize, reinterpret_cast( data.data() ) ) ); + static_cast( m_device ), static_cast( m_shaderEXT ), &dataSize, reinterpret_cast( data.data() ) ) ); } } while ( result == VULKAN_HPP_NAMESPACE::Result::eIncomplete ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::ShaderEXT::getBinaryData" ); @@ -26658,8 +26881,10 @@ namespace VULKAN_HPP_NAMESPACE { VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencySleepModeNV && "Function requires " ); - VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkSetLatencySleepModeNV( - static_cast( m_device ), static_cast( m_swapchain ), reinterpret_cast( &sleepModeInfo ) ) ); + VULKAN_HPP_NAMESPACE::Result result = static_cast( + getDispatcher()->vkSetLatencySleepModeNV( static_cast( m_device ), + static_cast( m_swapchainKHR ), + reinterpret_cast( &sleepModeInfo ) ) ); VULKAN_HPP_NAMESPACE::detail::resultCheck( result, VULKAN_HPP_NAMESPACE_STRING "::SwapchainKHR::setLatencySleepModeNV" ); } @@ -26669,7 +26894,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkLatencySleepNV && "Function requires " ); getDispatcher()->vkLatencySleepNV( - static_cast( m_device ), static_cast( m_swapchain ), reinterpret_cast( &sleepInfo ) ); + static_cast( m_device ), static_cast( m_swapchainKHR ), reinterpret_cast( &sleepInfo ) ); } // wrapper function for command vkSetLatencyMarkerNV, see https://registry.khronos.org/vulkan/specs/latest/man/html/vkSetLatencyMarkerNV.html @@ -26678,7 +26903,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_ASSERT( getDispatcher()->vkSetLatencyMarkerNV && "Function requires " ); getDispatcher()->vkSetLatencyMarkerNV( static_cast( m_device ), - static_cast( m_swapchain ), + static_cast( m_swapchainKHR ), reinterpret_cast( &latencyMarkerInfo ) ); } @@ -26690,11 +26915,11 @@ namespace VULKAN_HPP_NAMESPACE std::vector timings; VULKAN_HPP_NAMESPACE::GetLatencyMarkerInfoNV latencyMarkerInfo; getDispatcher()->vkGetLatencyTimingsNV( - static_cast( m_device ), static_cast( m_swapchain ), reinterpret_cast( &latencyMarkerInfo ) ); + static_cast( m_device ), static_cast( m_swapchainKHR ), reinterpret_cast( &latencyMarkerInfo ) ); timings.resize( latencyMarkerInfo.timingCount ); latencyMarkerInfo.pTimings = timings.data(); getDispatcher()->vkGetLatencyTimingsNV( - static_cast( m_device ), static_cast( m_swapchain ), reinterpret_cast( &latencyMarkerInfo ) ); + static_cast( m_device ), static_cast( m_swapchainKHR ), reinterpret_cast( &latencyMarkerInfo ) ); return timings; } @@ -26945,6 +27170,53 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &bindDescriptorBufferEmbeddedSamplersInfo ) ); } + //=== VK_NV_external_compute_queue === + + // wrapper function for command vkCreateExternalComputeQueueNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkCreateExternalComputeQueueNV.html + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::detail::CreateReturnType::Type + Device::createExternalComputeQueueNV( VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + VULKAN_HPP_RAII_CREATE_NOEXCEPT + { + VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV externalQueue; + VULKAN_HPP_NAMESPACE::Result result = static_cast( getDispatcher()->vkCreateExternalComputeQueueNV( + static_cast( m_device ), + reinterpret_cast( &createInfo ), + reinterpret_cast( static_cast( allocator ) ), + reinterpret_cast( &externalQueue ) ) ); + if ( result != VULKAN_HPP_NAMESPACE::Result::eSuccess ) + { +# if defined( VULKAN_HPP_RAII_NO_EXCEPTIONS ) + return VULKAN_HPP_UNEXPECTED( result ); +# else + VULKAN_HPP_NAMESPACE::detail::throwResultException( result, "Device::createExternalComputeQueueNV" ); +# endif + } + + return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::ExternalComputeQueueNV( + *this, *reinterpret_cast( &externalQueue ), allocator ); + } + + // wrapper function for command vkGetExternalComputeQueueDataNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/vkGetExternalComputeQueueDataNV.html + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::pair + ExternalComputeQueueNV::getData() const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetExternalComputeQueueDataNV && + "Function requires " ); + + std::pair data_; + VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV & arams = data_.first; + DataType & data = data_.second; + getDispatcher()->vkGetExternalComputeQueueDataNV( + static_cast( m_externalComputeQueueNV ), reinterpret_cast( &arams ), &data ); + + return data_; + } + //=== VK_NV_cluster_acceleration_structure === // wrapper function for command vkGetClusterAccelerationStructureBuildSizesNV, see @@ -27133,7 +27405,7 @@ namespace VULKAN_HPP_NAMESPACE "Function requires " ); getDispatcher()->vkUpdateIndirectExecutionSetPipelineEXT( static_cast( m_device ), - static_cast( m_indirectExecutionSet ), + static_cast( m_indirectExecutionSetEXT ), executionSetWrites.size(), reinterpret_cast( executionSetWrites.data() ) ); } @@ -27147,7 +27419,7 @@ namespace VULKAN_HPP_NAMESPACE "Function requires " ); getDispatcher()->vkUpdateIndirectExecutionSetShaderEXT( static_cast( m_device ), - static_cast( m_indirectExecutionSet ), + static_cast( m_indirectExecutionSetEXT ), executionSetWrites.size(), reinterpret_cast( executionSetWrites.data() ) ); } diff --git a/include/vulkan/vulkan_shared.hpp b/include/vulkan/vulkan_shared.hpp index 9edcabd..6cdd136 100644 --- a/include/vulkan/vulkan_shared.hpp +++ b/include/vulkan/vulkan_shared.hpp @@ -981,6 +981,17 @@ namespace VULKAN_HPP_NAMESPACE using SharedPipelineBinaryKHR = SharedHandle; + //=== VK_NV_external_compute_queue === + template <> + class SharedHandleTraits + { + public: + using DestructorType = Device; + using deleter = detail::ObjectDestroyShared; + }; + + using SharedExternalComputeQueueNV = SharedHandle; + //=== VK_EXT_device_generated_commands === template <> class SharedHandleTraits diff --git a/include/vulkan/vulkan_static_assertions.hpp b/include/vulkan/vulkan_static_assertions.hpp index 7799cd6..bec94a3 100644 --- a/include/vulkan/vulkan_static_assertions.hpp +++ b/include/vulkan/vulkan_static_assertions.hpp @@ -5402,6 +5402,44 @@ VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTileShadingFeaturesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTileShadingPropertiesQCOM ) == sizeof( VkPhysicalDeviceTileShadingPropertiesQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceTileShadingPropertiesQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::RenderPassTileShadingCreateInfoQCOM ) == sizeof( VkRenderPassTileShadingCreateInfoQCOM ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "RenderPassTileShadingCreateInfoQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerTileBeginInfoQCOM ) == sizeof( VkPerTileBeginInfoQCOM ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerTileBeginInfoQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PerTileEndInfoQCOM ) == sizeof( VkPerTileEndInfoQCOM ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PerTileEndInfoQCOM is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::DispatchTileInfoQCOM ) == sizeof( VkDispatchTileInfoQCOM ), "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "DispatchTileInfoQCOM is not nothrow_move_constructible!" ); + //=== VK_NV_low_latency === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::QueryLowLatencySupportNV ) == sizeof( VkQueryLowLatencySupportNV ), @@ -7865,6 +7903,42 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDeviceRawAccessChainsFeaturesNV is not nothrow_move_constructible!" ); +//=== VK_NV_external_compute_queue === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueNV ) == sizeof( VkExternalComputeQueueNV ), + "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_copy_constructible::value, + "ExternalComputeQueueNV is not copy_constructible!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalComputeQueueNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDeviceCreateInfoNV ) == sizeof( VkExternalComputeQueueDeviceCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalComputeQueueDeviceCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueCreateInfoNV ) == sizeof( VkExternalComputeQueueCreateInfoNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalComputeQueueCreateInfoNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ExternalComputeQueueDataParamsNV ) == sizeof( VkExternalComputeQueueDataParamsNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "ExternalComputeQueueDataParamsNV is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceExternalComputeQueuePropertiesNV ) == + sizeof( VkPhysicalDeviceExternalComputeQueuePropertiesNV ), + "struct and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, + "struct wrapper is not a standard layout!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, + "PhysicalDeviceExternalComputeQueuePropertiesNV is not nothrow_move_constructible!" ); + //=== VK_KHR_shader_relaxed_extended_instruction === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR ) == diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp index e976d8d..d58643a 100644 --- a/include/vulkan/vulkan_structs.hpp +++ b/include/vulkan/vulkan_structs.hpp @@ -38317,6 +38317,102 @@ namespace VULKAN_HPP_NAMESPACE uint32_t z = {}; }; + // wrapper struct for struct VkDispatchTileInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDispatchTileInfoQCOM.html + struct DispatchTileInfoQCOM + { + using NativeType = VkDispatchTileInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eDispatchTileInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR DispatchTileInfoQCOM( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} + + VULKAN_HPP_CONSTEXPR DispatchTileInfoQCOM( DispatchTileInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + DispatchTileInfoQCOM( VkDispatchTileInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : DispatchTileInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + DispatchTileInfoQCOM & operator=( DispatchTileInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + DispatchTileInfoQCOM & operator=( VkDispatchTileInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 DispatchTileInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkDispatchTileInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDispatchTileInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkDispatchTileInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkDispatchTileInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( DispatchTileInfoQCOM const & ) const = default; +#else + bool operator==( DispatchTileInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif + } + + bool operator!=( DispatchTileInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eDispatchTileInfoQCOM; + const void * pNext = {}; + }; + + template <> + struct CppType + { + using Type = DispatchTileInfoQCOM; + }; + // wrapper struct for struct VkDisplayEventInfoEXT, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkDisplayEventInfoEXT.html struct DisplayEventInfoEXT { @@ -43957,6 +44053,330 @@ namespace VULKAN_HPP_NAMESPACE using ExternalBufferPropertiesKHR = ExternalBufferProperties; + // wrapper struct for struct VkExternalComputeQueueCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueCreateInfoNV.html + struct ExternalComputeQueueCreateInfoNV + { + using NativeType = VkExternalComputeQueueCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalComputeQueueCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalComputeQueueCreateInfoNV( VULKAN_HPP_NAMESPACE::Queue preferredQueue_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , preferredQueue{ preferredQueue_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalComputeQueueCreateInfoNV( ExternalComputeQueueCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalComputeQueueCreateInfoNV( VkExternalComputeQueueCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalComputeQueueCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ExternalComputeQueueCreateInfoNV & operator=( ExternalComputeQueueCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalComputeQueueCreateInfoNV & operator=( VkExternalComputeQueueCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueCreateInfoNV & setPreferredQueue( VULKAN_HPP_NAMESPACE::Queue preferredQueue_ ) VULKAN_HPP_NOEXCEPT + { + preferredQueue = preferredQueue_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalComputeQueueCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalComputeQueueCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalComputeQueueCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalComputeQueueCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, preferredQueue ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalComputeQueueCreateInfoNV const & ) const = default; +#else + bool operator==( ExternalComputeQueueCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( preferredQueue == rhs.preferredQueue ); +# endif + } + + bool operator!=( ExternalComputeQueueCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalComputeQueueCreateInfoNV; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::Queue preferredQueue = {}; + }; + + template <> + struct CppType + { + using Type = ExternalComputeQueueCreateInfoNV; + }; + + // wrapper struct for struct VkExternalComputeQueueDataParamsNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueDataParamsNV.html + struct ExternalComputeQueueDataParamsNV + { + using NativeType = VkExternalComputeQueueDataParamsNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalComputeQueueDataParamsNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalComputeQueueDataParamsNV( uint32_t deviceIndex_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , deviceIndex{ deviceIndex_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalComputeQueueDataParamsNV( ExternalComputeQueueDataParamsNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalComputeQueueDataParamsNV( VkExternalComputeQueueDataParamsNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalComputeQueueDataParamsNV( *reinterpret_cast( &rhs ) ) + { + } + + ExternalComputeQueueDataParamsNV & operator=( ExternalComputeQueueDataParamsNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalComputeQueueDataParamsNV & operator=( VkExternalComputeQueueDataParamsNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDataParamsNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDataParamsNV & setDeviceIndex( uint32_t deviceIndex_ ) VULKAN_HPP_NOEXCEPT + { + deviceIndex = deviceIndex_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalComputeQueueDataParamsNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalComputeQueueDataParamsNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalComputeQueueDataParamsNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalComputeQueueDataParamsNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, deviceIndex ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalComputeQueueDataParamsNV const & ) const = default; +#else + bool operator==( ExternalComputeQueueDataParamsNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( deviceIndex == rhs.deviceIndex ); +# endif + } + + bool operator!=( ExternalComputeQueueDataParamsNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalComputeQueueDataParamsNV; + const void * pNext = {}; + uint32_t deviceIndex = {}; + }; + + template <> + struct CppType + { + using Type = ExternalComputeQueueDataParamsNV; + }; + + // wrapper struct for struct VkExternalComputeQueueDeviceCreateInfoNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalComputeQueueDeviceCreateInfoNV.html + struct ExternalComputeQueueDeviceCreateInfoNV + { + using NativeType = VkExternalComputeQueueDeviceCreateInfoNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eExternalComputeQueueDeviceCreateInfoNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ExternalComputeQueueDeviceCreateInfoNV( uint32_t reservedExternalQueues_ = {}, const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , reservedExternalQueues{ reservedExternalQueues_ } + { + } + + VULKAN_HPP_CONSTEXPR ExternalComputeQueueDeviceCreateInfoNV( ExternalComputeQueueDeviceCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ExternalComputeQueueDeviceCreateInfoNV( VkExternalComputeQueueDeviceCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + : ExternalComputeQueueDeviceCreateInfoNV( *reinterpret_cast( &rhs ) ) + { + } + + ExternalComputeQueueDeviceCreateInfoNV & operator=( ExternalComputeQueueDeviceCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + ExternalComputeQueueDeviceCreateInfoNV & operator=( VkExternalComputeQueueDeviceCreateInfoNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDeviceCreateInfoNV & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ExternalComputeQueueDeviceCreateInfoNV & setReservedExternalQueues( uint32_t reservedExternalQueues_ ) VULKAN_HPP_NOEXCEPT + { + reservedExternalQueues = reservedExternalQueues_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkExternalComputeQueueDeviceCreateInfoNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalComputeQueueDeviceCreateInfoNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkExternalComputeQueueDeviceCreateInfoNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkExternalComputeQueueDeviceCreateInfoNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, reservedExternalQueues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ExternalComputeQueueDeviceCreateInfoNV const & ) const = default; +#else + bool operator==( ExternalComputeQueueDeviceCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( reservedExternalQueues == rhs.reservedExternalQueues ); +# endif + } + + bool operator!=( ExternalComputeQueueDeviceCreateInfoNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eExternalComputeQueueDeviceCreateInfoNV; + const void * pNext = {}; + uint32_t reservedExternalQueues = {}; + }; + + template <> + struct CppType + { + using Type = ExternalComputeQueueDeviceCreateInfoNV; + }; + // wrapper struct for struct VkExternalFenceProperties, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkExternalFenceProperties.html struct ExternalFenceProperties { @@ -68337,6 +68757,195 @@ namespace VULKAN_HPP_NAMESPACE uint64_t presentMargin = {}; }; + // wrapper struct for struct VkPerTileBeginInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerTileBeginInfoQCOM.html + struct PerTileBeginInfoQCOM + { + using NativeType = VkPerTileBeginInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerTileBeginInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PerTileBeginInfoQCOM( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} + + VULKAN_HPP_CONSTEXPR PerTileBeginInfoQCOM( PerTileBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerTileBeginInfoQCOM( VkPerTileBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PerTileBeginInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PerTileBeginInfoQCOM & operator=( PerTileBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerTileBeginInfoQCOM & operator=( VkPerTileBeginInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PerTileBeginInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPerTileBeginInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerTileBeginInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerTileBeginInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerTileBeginInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PerTileBeginInfoQCOM const & ) const = default; +#else + bool operator==( PerTileBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif + } + + bool operator!=( PerTileBeginInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerTileBeginInfoQCOM; + const void * pNext = {}; + }; + + template <> + struct CppType + { + using Type = PerTileBeginInfoQCOM; + }; + + // wrapper struct for struct VkPerTileEndInfoQCOM, see https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerTileEndInfoQCOM.html + struct PerTileEndInfoQCOM + { + using NativeType = VkPerTileEndInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePerTileEndInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PerTileEndInfoQCOM( const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT : pNext{ pNext_ } {} + + VULKAN_HPP_CONSTEXPR PerTileEndInfoQCOM( PerTileEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PerTileEndInfoQCOM( VkPerTileEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT : PerTileEndInfoQCOM( *reinterpret_cast( &rhs ) ) {} + + PerTileEndInfoQCOM & operator=( PerTileEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PerTileEndInfoQCOM & operator=( VkPerTileEndInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PerTileEndInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPerTileEndInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerTileEndInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPerTileEndInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPerTileEndInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PerTileEndInfoQCOM const & ) const = default; +#else + bool operator==( PerTileEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ); +# endif + } + + bool operator!=( PerTileEndInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePerTileEndInfoQCOM; + const void * pNext = {}; + }; + + template <> + struct CppType + { + using Type = PerTileEndInfoQCOM; + }; + // wrapper struct for struct VkPerformanceConfigurationAcquireInfoINTEL, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPerformanceConfigurationAcquireInfoINTEL.html struct PerformanceConfigurationAcquireInfoINTEL @@ -80102,6 +80711,105 @@ namespace VULKAN_HPP_NAMESPACE using PhysicalDeviceExternalBufferInfoKHR = PhysicalDeviceExternalBufferInfo; + // wrapper struct for struct VkPhysicalDeviceExternalComputeQueuePropertiesNV, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalComputeQueuePropertiesNV.html + struct PhysicalDeviceExternalComputeQueuePropertiesNV + { + using NativeType = VkPhysicalDeviceExternalComputeQueuePropertiesNV; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceExternalComputeQueuePropertiesNV; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceExternalComputeQueuePropertiesNV( uint32_t externalDataSize_ = {}, + uint32_t maxExternalQueues_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , externalDataSize{ externalDataSize_ } + , maxExternalQueues{ maxExternalQueues_ } + { + } + + VULKAN_HPP_CONSTEXPR + PhysicalDeviceExternalComputeQueuePropertiesNV( PhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceExternalComputeQueuePropertiesNV( VkPhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceExternalComputeQueuePropertiesNV( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceExternalComputeQueuePropertiesNV & operator=( PhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceExternalComputeQueuePropertiesNV & operator=( VkPhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceExternalComputeQueuePropertiesNV const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalComputeQueuePropertiesNV &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalComputeQueuePropertiesNV const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceExternalComputeQueuePropertiesNV *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, externalDataSize, maxExternalQueues ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceExternalComputeQueuePropertiesNV const & ) const = default; +#else + bool operator==( PhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( externalDataSize == rhs.externalDataSize ) && ( maxExternalQueues == rhs.maxExternalQueues ); +# endif + } + + bool operator!=( PhysicalDeviceExternalComputeQueuePropertiesNV const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceExternalComputeQueuePropertiesNV; + void * pNext = {}; + uint32_t externalDataSize = {}; + uint32_t maxExternalQueues = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceExternalComputeQueuePropertiesNV; + }; + // wrapper struct for struct VkPhysicalDeviceExternalFenceInfo, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceExternalFenceInfo.html struct PhysicalDeviceExternalFenceInfo @@ -107227,6 +107935,391 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceTilePropertiesFeaturesQCOM; }; + // wrapper struct for struct VkPhysicalDeviceTileShadingFeaturesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileShadingFeaturesQCOM.html + struct PhysicalDeviceTileShadingFeaturesQCOM + { + using NativeType = VkPhysicalDeviceTileShadingFeaturesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileShadingFeaturesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileShadingFeaturesQCOM( VULKAN_HPP_NAMESPACE::Bool32 tileShading_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileShadingFragmentStage_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileShadingColorAttachments_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileShadingDepthAttachments_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileShadingStencilAttachments_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileShadingInputAttachments_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileShadingSampledAttachments_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileShadingPerTileDraw_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileShadingPerTileDispatch_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileShadingDispatchTile_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileShadingApron_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileShadingAnisotropicApron_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileShadingAtomicOps_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 tileShadingImageProcessing_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , tileShading{ tileShading_ } + , tileShadingFragmentStage{ tileShadingFragmentStage_ } + , tileShadingColorAttachments{ tileShadingColorAttachments_ } + , tileShadingDepthAttachments{ tileShadingDepthAttachments_ } + , tileShadingStencilAttachments{ tileShadingStencilAttachments_ } + , tileShadingInputAttachments{ tileShadingInputAttachments_ } + , tileShadingSampledAttachments{ tileShadingSampledAttachments_ } + , tileShadingPerTileDraw{ tileShadingPerTileDraw_ } + , tileShadingPerTileDispatch{ tileShadingPerTileDispatch_ } + , tileShadingDispatchTile{ tileShadingDispatchTile_ } + , tileShadingApron{ tileShadingApron_ } + , tileShadingAnisotropicApron{ tileShadingAnisotropicApron_ } + , tileShadingAtomicOps{ tileShadingAtomicOps_ } + , tileShadingImageProcessing{ tileShadingImageProcessing_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileShadingFeaturesQCOM( PhysicalDeviceTileShadingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTileShadingFeaturesQCOM( VkPhysicalDeviceTileShadingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTileShadingFeaturesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTileShadingFeaturesQCOM & operator=( PhysicalDeviceTileShadingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTileShadingFeaturesQCOM & operator=( VkPhysicalDeviceTileShadingFeaturesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShading( VULKAN_HPP_NAMESPACE::Bool32 tileShading_ ) VULKAN_HPP_NOEXCEPT + { + tileShading = tileShading_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & + setTileShadingFragmentStage( VULKAN_HPP_NAMESPACE::Bool32 tileShadingFragmentStage_ ) VULKAN_HPP_NOEXCEPT + { + tileShadingFragmentStage = tileShadingFragmentStage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & + setTileShadingColorAttachments( VULKAN_HPP_NAMESPACE::Bool32 tileShadingColorAttachments_ ) VULKAN_HPP_NOEXCEPT + { + tileShadingColorAttachments = tileShadingColorAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & + setTileShadingDepthAttachments( VULKAN_HPP_NAMESPACE::Bool32 tileShadingDepthAttachments_ ) VULKAN_HPP_NOEXCEPT + { + tileShadingDepthAttachments = tileShadingDepthAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & + setTileShadingStencilAttachments( VULKAN_HPP_NAMESPACE::Bool32 tileShadingStencilAttachments_ ) VULKAN_HPP_NOEXCEPT + { + tileShadingStencilAttachments = tileShadingStencilAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & + setTileShadingInputAttachments( VULKAN_HPP_NAMESPACE::Bool32 tileShadingInputAttachments_ ) VULKAN_HPP_NOEXCEPT + { + tileShadingInputAttachments = tileShadingInputAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & + setTileShadingSampledAttachments( VULKAN_HPP_NAMESPACE::Bool32 tileShadingSampledAttachments_ ) VULKAN_HPP_NOEXCEPT + { + tileShadingSampledAttachments = tileShadingSampledAttachments_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & + setTileShadingPerTileDraw( VULKAN_HPP_NAMESPACE::Bool32 tileShadingPerTileDraw_ ) VULKAN_HPP_NOEXCEPT + { + tileShadingPerTileDraw = tileShadingPerTileDraw_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & + setTileShadingPerTileDispatch( VULKAN_HPP_NAMESPACE::Bool32 tileShadingPerTileDispatch_ ) VULKAN_HPP_NOEXCEPT + { + tileShadingPerTileDispatch = tileShadingPerTileDispatch_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & + setTileShadingDispatchTile( VULKAN_HPP_NAMESPACE::Bool32 tileShadingDispatchTile_ ) VULKAN_HPP_NOEXCEPT + { + tileShadingDispatchTile = tileShadingDispatchTile_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & setTileShadingApron( VULKAN_HPP_NAMESPACE::Bool32 tileShadingApron_ ) VULKAN_HPP_NOEXCEPT + { + tileShadingApron = tileShadingApron_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & + setTileShadingAnisotropicApron( VULKAN_HPP_NAMESPACE::Bool32 tileShadingAnisotropicApron_ ) VULKAN_HPP_NOEXCEPT + { + tileShadingAnisotropicApron = tileShadingAnisotropicApron_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & + setTileShadingAtomicOps( VULKAN_HPP_NAMESPACE::Bool32 tileShadingAtomicOps_ ) VULKAN_HPP_NOEXCEPT + { + tileShadingAtomicOps = tileShadingAtomicOps_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceTileShadingFeaturesQCOM & + setTileShadingImageProcessing( VULKAN_HPP_NAMESPACE::Bool32 tileShadingImageProcessing_ ) VULKAN_HPP_NOEXCEPT + { + tileShadingImageProcessing = tileShadingImageProcessing_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkPhysicalDeviceTileShadingFeaturesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileShadingFeaturesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileShadingFeaturesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileShadingFeaturesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, + pNext, + tileShading, + tileShadingFragmentStage, + tileShadingColorAttachments, + tileShadingDepthAttachments, + tileShadingStencilAttachments, + tileShadingInputAttachments, + tileShadingSampledAttachments, + tileShadingPerTileDraw, + tileShadingPerTileDispatch, + tileShadingDispatchTile, + tileShadingApron, + tileShadingAnisotropicApron, + tileShadingAtomicOps, + tileShadingImageProcessing ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTileShadingFeaturesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceTileShadingFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( tileShading == rhs.tileShading ) && + ( tileShadingFragmentStage == rhs.tileShadingFragmentStage ) && ( tileShadingColorAttachments == rhs.tileShadingColorAttachments ) && + ( tileShadingDepthAttachments == rhs.tileShadingDepthAttachments ) && ( tileShadingStencilAttachments == rhs.tileShadingStencilAttachments ) && + ( tileShadingInputAttachments == rhs.tileShadingInputAttachments ) && ( tileShadingSampledAttachments == rhs.tileShadingSampledAttachments ) && + ( tileShadingPerTileDraw == rhs.tileShadingPerTileDraw ) && ( tileShadingPerTileDispatch == rhs.tileShadingPerTileDispatch ) && + ( tileShadingDispatchTile == rhs.tileShadingDispatchTile ) && ( tileShadingApron == rhs.tileShadingApron ) && + ( tileShadingAnisotropicApron == rhs.tileShadingAnisotropicApron ) && ( tileShadingAtomicOps == rhs.tileShadingAtomicOps ) && + ( tileShadingImageProcessing == rhs.tileShadingImageProcessing ); +# endif + } + + bool operator!=( PhysicalDeviceTileShadingFeaturesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTileShadingFeaturesQCOM; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShading = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShadingFragmentStage = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShadingColorAttachments = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShadingDepthAttachments = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShadingStencilAttachments = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShadingInputAttachments = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShadingSampledAttachments = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShadingPerTileDraw = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShadingPerTileDispatch = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShadingDispatchTile = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShadingApron = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShadingAnisotropicApron = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShadingAtomicOps = {}; + VULKAN_HPP_NAMESPACE::Bool32 tileShadingImageProcessing = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceTileShadingFeaturesQCOM; + }; + + // wrapper struct for struct VkPhysicalDeviceTileShadingPropertiesQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTileShadingPropertiesQCOM.html + struct PhysicalDeviceTileShadingPropertiesQCOM + { + using NativeType = VkPhysicalDeviceTileShadingPropertiesQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceTileShadingPropertiesQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileShadingPropertiesQCOM( uint32_t maxApronSize_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 preferNonCoherent_ = {}, + VULKAN_HPP_NAMESPACE::Extent2D tileGranularity_ = {}, + VULKAN_HPP_NAMESPACE::Extent2D maxTileShadingRate_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , maxApronSize{ maxApronSize_ } + , preferNonCoherent{ preferNonCoherent_ } + , tileGranularity{ tileGranularity_ } + , maxTileShadingRate{ maxTileShadingRate_ } + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceTileShadingPropertiesQCOM( PhysicalDeviceTileShadingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceTileShadingPropertiesQCOM( VkPhysicalDeviceTileShadingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceTileShadingPropertiesQCOM( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceTileShadingPropertiesQCOM & operator=( PhysicalDeviceTileShadingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + PhysicalDeviceTileShadingPropertiesQCOM & operator=( VkPhysicalDeviceTileShadingPropertiesQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceTileShadingPropertiesQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileShadingPropertiesQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileShadingPropertiesQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkPhysicalDeviceTileShadingPropertiesQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, maxApronSize, preferNonCoherent, tileGranularity, maxTileShadingRate ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceTileShadingPropertiesQCOM const & ) const = default; +#else + bool operator==( PhysicalDeviceTileShadingPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( maxApronSize == rhs.maxApronSize ) && ( preferNonCoherent == rhs.preferNonCoherent ) && + ( tileGranularity == rhs.tileGranularity ) && ( maxTileShadingRate == rhs.maxTileShadingRate ); +# endif + } + + bool operator!=( PhysicalDeviceTileShadingPropertiesQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceTileShadingPropertiesQCOM; + void * pNext = {}; + uint32_t maxApronSize = {}; + VULKAN_HPP_NAMESPACE::Bool32 preferNonCoherent = {}; + VULKAN_HPP_NAMESPACE::Extent2D tileGranularity = {}; + VULKAN_HPP_NAMESPACE::Extent2D maxTileShadingRate = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceTileShadingPropertiesQCOM; + }; + // wrapper struct for struct VkPhysicalDeviceTimelineSemaphoreFeatures, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkPhysicalDeviceTimelineSemaphoreFeatures.html struct PhysicalDeviceTimelineSemaphoreFeatures @@ -128719,6 +129812,127 @@ namespace VULKAN_HPP_NAMESPACE using Type = RenderPassSubpassFeedbackCreateInfoEXT; }; + // wrapper struct for struct VkRenderPassTileShadingCreateInfoQCOM, see + // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassTileShadingCreateInfoQCOM.html + struct RenderPassTileShadingCreateInfoQCOM + { + using NativeType = VkRenderPassTileShadingCreateInfoQCOM; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eRenderPassTileShadingCreateInfoQCOM; + +#if !defined( VULKAN_HPP_NO_CONSTRUCTORS ) && !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR RenderPassTileShadingCreateInfoQCOM( VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagsQCOM flags_ = {}, + VULKAN_HPP_NAMESPACE::Extent2D tileApronSize_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext{ pNext_ } + , flags{ flags_ } + , tileApronSize{ tileApronSize_ } + { + } + + VULKAN_HPP_CONSTEXPR RenderPassTileShadingCreateInfoQCOM( RenderPassTileShadingCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + RenderPassTileShadingCreateInfoQCOM( VkRenderPassTileShadingCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + : RenderPassTileShadingCreateInfoQCOM( *reinterpret_cast( &rhs ) ) + { + } + + RenderPassTileShadingCreateInfoQCOM & operator=( RenderPassTileShadingCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_CONSTRUCTORS*/ + + RenderPassTileShadingCreateInfoQCOM & operator=( VkRenderPassTileShadingCreateInfoQCOM const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_SETTERS ) && !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM & setFlags( VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagsQCOM flags_ ) VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 RenderPassTileShadingCreateInfoQCOM & setTileApronSize( VULKAN_HPP_NAMESPACE::Extent2D const & tileApronSize_ ) VULKAN_HPP_NOEXCEPT + { + tileApronSize = tileApronSize_; + return *this; + } +#endif /*VULKAN_HPP_NO_SETTERS*/ + + operator VkRenderPassTileShadingCreateInfoQCOM const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassTileShadingCreateInfoQCOM &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkRenderPassTileShadingCreateInfoQCOM const *() const VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + + operator VkRenderPassTileShadingCreateInfoQCOM *() VULKAN_HPP_NOEXCEPT + { + return reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std::tuple +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, flags, tileApronSize ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( RenderPassTileShadingCreateInfoQCOM const & ) const = default; +#else + bool operator==( RenderPassTileShadingCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { +# if defined( VULKAN_HPP_USE_REFLECT ) + return this->reflect() == rhs.reflect(); +# else + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( tileApronSize == rhs.tileApronSize ); +# endif + } + + bool operator!=( RenderPassTileShadingCreateInfoQCOM const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eRenderPassTileShadingCreateInfoQCOM; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::TileShadingRenderPassFlagsQCOM flags = {}; + VULKAN_HPP_NAMESPACE::Extent2D tileApronSize = {}; + }; + + template <> + struct CppType + { + using Type = RenderPassTileShadingCreateInfoQCOM; + }; + // wrapper struct for struct VkRenderPassTransformBeginInfoQCOM, see // https://registry.khronos.org/vulkan/specs/latest/man/html/VkRenderPassTransformBeginInfoQCOM.html struct RenderPassTransformBeginInfoQCOM diff --git a/include/vulkan/vulkan_to_string.hpp b/include/vulkan/vulkan_to_string.hpp index b9282b8..bf99a45 100644 --- a/include/vulkan/vulkan_to_string.hpp +++ b/include/vulkan/vulkan_to_string.hpp @@ -1166,6 +1166,8 @@ namespace VULKAN_HPP_NAMESPACE result += " FragmentRegionQCOM |"; if ( value & SubpassDescriptionFlagBits::eShaderResolveQCOM ) result += " ShaderResolveQCOM |"; + if ( value & SubpassDescriptionFlagBits::eTileShadingApronQCOM ) + result += " TileShadingApronQCOM |"; if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT ) result += " RasterizationOrderAttachmentColorAccessEXT |"; if ( value & SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT ) @@ -1773,6 +1775,10 @@ namespace VULKAN_HPP_NAMESPACE result += " VideoEncodeReadKHR |"; if ( value & AccessFlagBits2::eVideoEncodeWriteKHR ) result += " VideoEncodeWriteKHR |"; + if ( value & AccessFlagBits2::eShaderTileAttachmentReadQCOM ) + result += " ShaderTileAttachmentReadQCOM |"; + if ( value & AccessFlagBits2::eShaderTileAttachmentWriteQCOM ) + result += " ShaderTileAttachmentWriteQCOM |"; if ( value & AccessFlagBits2::eTransformFeedbackWriteEXT ) result += " TransformFeedbackWriteEXT |"; if ( value & AccessFlagBits2::eTransformFeedbackCounterReadEXT ) @@ -3347,6 +3353,23 @@ namespace VULKAN_HPP_NAMESPACE return result; } + //=== VK_QCOM_tile_shading === + + VULKAN_HPP_INLINE std::string to_string( TileShadingRenderPassFlagsQCOM value ) + { + std::string result = "{"; + if ( value & TileShadingRenderPassFlagBitsQCOM::eEnable ) + result += " Enable |"; + if ( value & TileShadingRenderPassFlagBitsQCOM::ePerTileExecution ) + result += " PerTileExecution |"; + + if ( result.size() > 1 ) + result.back() = '}'; + else + result = "{}"; + return result; + } + #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === @@ -4717,6 +4740,12 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceCudaKernelLaunchFeaturesNV: return "PhysicalDeviceCudaKernelLaunchFeaturesNV"; case StructureType::ePhysicalDeviceCudaKernelLaunchPropertiesNV: return "PhysicalDeviceCudaKernelLaunchPropertiesNV"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ + case StructureType::ePhysicalDeviceTileShadingFeaturesQCOM: return "PhysicalDeviceTileShadingFeaturesQCOM"; + case StructureType::ePhysicalDeviceTileShadingPropertiesQCOM: return "PhysicalDeviceTileShadingPropertiesQCOM"; + case StructureType::eRenderPassTileShadingCreateInfoQCOM: return "RenderPassTileShadingCreateInfoQCOM"; + case StructureType::ePerTileBeginInfoQCOM: return "PerTileBeginInfoQCOM"; + case StructureType::ePerTileEndInfoQCOM: return "PerTileEndInfoQCOM"; + case StructureType::eDispatchTileInfoQCOM: return "DispatchTileInfoQCOM"; case StructureType::eQueryLowLatencySupportNV: return "QueryLowLatencySupportNV"; #if defined( VK_USE_PLATFORM_METAL_EXT ) case StructureType::eExportMetalObjectCreateInfoEXT: return "ExportMetalObjectCreateInfoEXT"; @@ -5022,6 +5051,10 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eVideoEncodeAv1QuantizationMapCapabilitiesKHR: return "VideoEncodeAv1QuantizationMapCapabilitiesKHR"; case StructureType::eVideoFormatAv1QuantizationMapPropertiesKHR: return "VideoFormatAv1QuantizationMapPropertiesKHR"; case StructureType::ePhysicalDeviceRawAccessChainsFeaturesNV: return "PhysicalDeviceRawAccessChainsFeaturesNV"; + case StructureType::eExternalComputeQueueDeviceCreateInfoNV: return "ExternalComputeQueueDeviceCreateInfoNV"; + case StructureType::eExternalComputeQueueCreateInfoNV: return "ExternalComputeQueueCreateInfoNV"; + case StructureType::eExternalComputeQueueDataParamsNV: return "ExternalComputeQueueDataParamsNV"; + case StructureType::ePhysicalDeviceExternalComputeQueuePropertiesNV: return "PhysicalDeviceExternalComputeQueuePropertiesNV"; case StructureType::ePhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR: return "PhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR"; case StructureType::ePhysicalDeviceCommandBufferInheritanceFeaturesNV: return "PhysicalDeviceCommandBufferInheritanceFeaturesNV"; case StructureType::ePhysicalDeviceMaintenance7FeaturesKHR: return "PhysicalDeviceMaintenance7FeaturesKHR"; @@ -5165,6 +5198,7 @@ namespace VULKAN_HPP_NAMESPACE case ObjectType::eOpticalFlowSessionNV: return "OpticalFlowSessionNV"; case ObjectType::eShaderEXT: return "ShaderEXT"; case ObjectType::ePipelineBinaryKHR: return "PipelineBinaryKHR"; + case ObjectType::eExternalComputeQueueNV: return "ExternalComputeQueueNV"; case ObjectType::eIndirectCommandsLayoutEXT: return "IndirectCommandsLayoutEXT"; case ObjectType::eIndirectExecutionSetEXT: return "IndirectExecutionSetEXT"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; @@ -6697,6 +6731,7 @@ namespace VULKAN_HPP_NAMESPACE case SubpassDescriptionFlagBits::ePerViewPositionXOnlyNVX: return "PerViewPositionXOnlyNVX"; case SubpassDescriptionFlagBits::eFragmentRegionQCOM: return "FragmentRegionQCOM"; case SubpassDescriptionFlagBits::eShaderResolveQCOM: return "ShaderResolveQCOM"; + case SubpassDescriptionFlagBits::eTileShadingApronQCOM: return "TileShadingApronQCOM"; case SubpassDescriptionFlagBits::eRasterizationOrderAttachmentColorAccessEXT: return "RasterizationOrderAttachmentColorAccessEXT"; case SubpassDescriptionFlagBits::eRasterizationOrderAttachmentDepthAccessEXT: return "RasterizationOrderAttachmentDepthAccessEXT"; case SubpassDescriptionFlagBits::eRasterizationOrderAttachmentStencilAccessEXT: return "RasterizationOrderAttachmentStencilAccessEXT"; @@ -7245,6 +7280,8 @@ namespace VULKAN_HPP_NAMESPACE case AccessFlagBits2::eVideoDecodeWriteKHR: return "VideoDecodeWriteKHR"; case AccessFlagBits2::eVideoEncodeReadKHR: return "VideoEncodeReadKHR"; case AccessFlagBits2::eVideoEncodeWriteKHR: return "VideoEncodeWriteKHR"; + case AccessFlagBits2::eShaderTileAttachmentReadQCOM: return "ShaderTileAttachmentReadQCOM"; + case AccessFlagBits2::eShaderTileAttachmentWriteQCOM: return "ShaderTileAttachmentWriteQCOM"; case AccessFlagBits2::eTransformFeedbackWriteEXT: return "TransformFeedbackWriteEXT"; case AccessFlagBits2::eTransformFeedbackCounterReadEXT: return "TransformFeedbackCounterReadEXT"; case AccessFlagBits2::eTransformFeedbackCounterWriteEXT: return "TransformFeedbackCounterWriteEXT"; @@ -9010,6 +9047,18 @@ namespace VULKAN_HPP_NAMESPACE } } + //=== VK_QCOM_tile_shading === + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string to_string( TileShadingRenderPassFlagBitsQCOM value ) + { + switch ( value ) + { + case TileShadingRenderPassFlagBitsQCOM::eEnable: return "Enable"; + case TileShadingRenderPassFlagBitsQCOM::ePerTileExecution: return "PerTileExecution"; + default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; + } + } + #if defined( VK_USE_PLATFORM_METAL_EXT ) //=== VK_EXT_metal_objects === diff --git a/registry/validusage.json b/registry/validusage.json index 6c2ea2d..0bc1e5f 100644 --- a/registry/validusage.json +++ b/registry/validusage.json @@ -1,9 +1,9 @@ { "version info": { "schema version": 2, - "api version": "1.4.311", - "comment": "from git branch: github-main commit: 7719d5eb8eb1df49469cdf684c6b370d0ee56a34", - "date": "2025-03-21 06:09:57Z" + "api version": "1.4.312", + "comment": "from git branch: github-main commit: ec56ad8828af2b089de2fc7a64cf59c588d8c753", + "date": "2025-04-04 11:11:05Z" }, "validation": { "vkGetInstanceProcAddr": { @@ -379,7 +379,7 @@ }, { "vuid": "VUID-VkPhysicalDeviceProperties2-pNext-pNext", - "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceAccelerationStructurePropertiesKHR, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceClusterAccelerationStructurePropertiesNV, VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI, VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrix2PropertiesNV, VkPhysicalDeviceCooperativeMatrixPropertiesKHR, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceCooperativeVectorPropertiesNV, VkPhysicalDeviceCopyMemoryIndirectPropertiesNV, VkPhysicalDeviceCudaKernelLaunchPropertiesNV, VkPhysicalDeviceCustomBorderColorPropertiesEXT, VkPhysicalDeviceDepthStencilResolveProperties, VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, VkPhysicalDeviceDescriptorBufferPropertiesEXT, VkPhysicalDeviceDescriptorIndexingProperties, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDisplacementMicromapPropertiesNV, VkPhysicalDeviceDriverProperties, VkPhysicalDeviceDrmPropertiesEXT, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT, VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV, VkPhysicalDeviceExternalFormatResolvePropertiesANDROID, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsProperties, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT, VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR, VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV, VkPhysicalDeviceFragmentShadingRatePropertiesKHR, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, VkPhysicalDeviceHostImageCopyProperties, VkPhysicalDeviceIDProperties, VkPhysicalDeviceImageAlignmentControlPropertiesMESA, VkPhysicalDeviceImageProcessing2PropertiesQCOM, VkPhysicalDeviceImageProcessingPropertiesQCOM, VkPhysicalDeviceInlineUniformBlockProperties, VkPhysicalDeviceLayeredApiPropertiesListKHR, VkPhysicalDeviceLayeredDriverPropertiesMSFT, VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT, VkPhysicalDeviceLineRasterizationProperties, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMaintenance4Properties, VkPhysicalDeviceMaintenance5Properties, VkPhysicalDeviceMaintenance6Properties, VkPhysicalDeviceMaintenance7PropertiesKHR, VkPhysicalDeviceMapMemoryPlacedPropertiesEXT, VkPhysicalDeviceMemoryDecompressionPropertiesNV, VkPhysicalDeviceMeshShaderPropertiesEXT, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiDrawPropertiesEXT, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDeviceNestedCommandBufferPropertiesEXT, VkPhysicalDeviceOpacityMicromapPropertiesEXT, VkPhysicalDeviceOpticalFlowPropertiesNV, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV, VkPhysicalDevicePerformanceQueryPropertiesKHR, VkPhysicalDevicePipelineBinaryPropertiesKHR, VkPhysicalDevicePipelineRobustnessProperties, VkPhysicalDevicePointClippingProperties, VkPhysicalDevicePortabilitySubsetPropertiesKHR, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDeviceProvokingVertexPropertiesEXT, VkPhysicalDevicePushDescriptorProperties, VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV, VkPhysicalDeviceRayTracingPipelinePropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceRenderPassStripedPropertiesARM, VkPhysicalDeviceRobustness2PropertiesEXT, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxProperties, VkPhysicalDeviceSchedulingControlsPropertiesARM, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM, VkPhysicalDeviceShaderCoreProperties2AMD, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderCorePropertiesARM, VkPhysicalDeviceShaderEnqueuePropertiesAMDX, VkPhysicalDeviceShaderIntegerDotProductProperties, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT, VkPhysicalDeviceShaderObjectPropertiesEXT, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShaderTileImagePropertiesEXT, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceSubgroupSizeControlProperties, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI, VkPhysicalDeviceTexelBufferAlignmentProperties, VkPhysicalDeviceTimelineSemaphoreProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, VkPhysicalDeviceVertexAttributeDivisorProperties, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT, VkPhysicalDeviceVulkan11Properties, VkPhysicalDeviceVulkan12Properties, VkPhysicalDeviceVulkan13Properties, or VkPhysicalDeviceVulkan14Properties", + "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceAccelerationStructurePropertiesKHR, VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceClusterAccelerationStructurePropertiesNV, VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI, VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrix2PropertiesNV, VkPhysicalDeviceCooperativeMatrixPropertiesKHR, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceCooperativeVectorPropertiesNV, VkPhysicalDeviceCopyMemoryIndirectPropertiesNV, VkPhysicalDeviceCudaKernelLaunchPropertiesNV, VkPhysicalDeviceCustomBorderColorPropertiesEXT, VkPhysicalDeviceDepthStencilResolveProperties, VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, VkPhysicalDeviceDescriptorBufferPropertiesEXT, VkPhysicalDeviceDescriptorIndexingProperties, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDisplacementMicromapPropertiesNV, VkPhysicalDeviceDriverProperties, VkPhysicalDeviceDrmPropertiesEXT, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT, VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV, VkPhysicalDeviceExternalComputeQueuePropertiesNV, VkPhysicalDeviceExternalFormatResolvePropertiesANDROID, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsProperties, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT, VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR, VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV, VkPhysicalDeviceFragmentShadingRatePropertiesKHR, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, VkPhysicalDeviceHostImageCopyProperties, VkPhysicalDeviceIDProperties, VkPhysicalDeviceImageAlignmentControlPropertiesMESA, VkPhysicalDeviceImageProcessing2PropertiesQCOM, VkPhysicalDeviceImageProcessingPropertiesQCOM, VkPhysicalDeviceInlineUniformBlockProperties, VkPhysicalDeviceLayeredApiPropertiesListKHR, VkPhysicalDeviceLayeredDriverPropertiesMSFT, VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT, VkPhysicalDeviceLineRasterizationProperties, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMaintenance4Properties, VkPhysicalDeviceMaintenance5Properties, VkPhysicalDeviceMaintenance6Properties, VkPhysicalDeviceMaintenance7PropertiesKHR, VkPhysicalDeviceMapMemoryPlacedPropertiesEXT, VkPhysicalDeviceMemoryDecompressionPropertiesNV, VkPhysicalDeviceMeshShaderPropertiesEXT, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiDrawPropertiesEXT, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDeviceNestedCommandBufferPropertiesEXT, VkPhysicalDeviceOpacityMicromapPropertiesEXT, VkPhysicalDeviceOpticalFlowPropertiesNV, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV, VkPhysicalDevicePerformanceQueryPropertiesKHR, VkPhysicalDevicePipelineBinaryPropertiesKHR, VkPhysicalDevicePipelineRobustnessProperties, VkPhysicalDevicePointClippingProperties, VkPhysicalDevicePortabilitySubsetPropertiesKHR, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDeviceProvokingVertexPropertiesEXT, VkPhysicalDevicePushDescriptorProperties, VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV, VkPhysicalDeviceRayTracingPipelinePropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceRenderPassStripedPropertiesARM, VkPhysicalDeviceRobustness2PropertiesEXT, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxProperties, VkPhysicalDeviceSchedulingControlsPropertiesARM, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM, VkPhysicalDeviceShaderCoreProperties2AMD, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderCorePropertiesARM, VkPhysicalDeviceShaderEnqueuePropertiesAMDX, VkPhysicalDeviceShaderIntegerDotProductProperties, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT, VkPhysicalDeviceShaderObjectPropertiesEXT, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShaderTileImagePropertiesEXT, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceSubgroupSizeControlProperties, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI, VkPhysicalDeviceTexelBufferAlignmentProperties, VkPhysicalDeviceTileShadingPropertiesQCOM, VkPhysicalDeviceTimelineSemaphoreProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, VkPhysicalDeviceVertexAttributeDivisorProperties, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT, VkPhysicalDeviceVulkan11Properties, VkPhysicalDeviceVulkan12Properties, VkPhysicalDeviceVulkan13Properties, or VkPhysicalDeviceVulkan14Properties", "page": "chapters/devsandqueues.html" }, { @@ -905,7 +905,7 @@ }, { "vuid": "VUID-VkDeviceCreateInfo-pNext-pNext", - "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceDeviceMemoryReportCreateInfoEXT, VkDeviceDiagnosticsConfigCreateInfoNV, VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkDevicePipelineBinaryInternalCacheControlKHR, VkDevicePrivateDataCreateInfo, VkDeviceQueueShaderCoreControlCreateInfoARM, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice4444FormatsFeaturesEXT, VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceAccelerationStructureFeaturesKHR, VkPhysicalDeviceAddressBindingReportFeaturesEXT, VkPhysicalDeviceAmigoProfilingFeaturesSEC, VkPhysicalDeviceAntiLagFeaturesAMD, VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeatures, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceClusterAccelerationStructureFeaturesNV, VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceColorWriteEnableFeaturesEXT, VkPhysicalDeviceCommandBufferInheritanceFeaturesNV, VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrix2FeaturesNV, VkPhysicalDeviceCooperativeMatrixFeaturesKHR, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCooperativeVectorFeaturesNV, VkPhysicalDeviceCopyMemoryIndirectFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceCubicClampFeaturesQCOM, VkPhysicalDeviceCubicWeightsFeaturesQCOM, VkPhysicalDeviceCudaKernelLaunchFeaturesNV, VkPhysicalDeviceCustomBorderColorFeaturesEXT, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthBiasControlFeaturesEXT, VkPhysicalDeviceDepthClampControlFeaturesEXT, VkPhysicalDeviceDepthClampZeroOneFeaturesKHR, VkPhysicalDeviceDepthClipControlFeaturesEXT, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorBufferFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV, VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, VkPhysicalDeviceDiagnosticsConfigFeaturesNV, VkPhysicalDeviceDisplacementMicromapFeaturesNV, VkPhysicalDeviceDynamicRenderingFeatures, VkPhysicalDeviceDynamicRenderingLocalReadFeatures, VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, VkPhysicalDeviceExternalFormatResolveFeaturesANDROID, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV, VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, VkPhysicalDeviceFaultFeaturesEXT, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, VkPhysicalDeviceFragmentShadingRateFeaturesKHR, VkPhysicalDeviceFrameBoundaryFeaturesEXT, VkPhysicalDeviceGlobalPriorityQueryFeatures, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, VkPhysicalDeviceHdrVividFeaturesHUAWEI, VkPhysicalDeviceHostImageCopyFeatures, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT, VkPhysicalDeviceImageAlignmentControlFeaturesMESA, VkPhysicalDeviceImageCompressionControlFeaturesEXT, VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, VkPhysicalDeviceImageProcessing2FeaturesQCOM, VkPhysicalDeviceImageProcessingFeaturesQCOM, VkPhysicalDeviceImageRobustnessFeatures, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT, VkPhysicalDeviceImageViewMinLodFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceIndexTypeUint8Features, VkPhysicalDeviceInheritedViewportScissorFeaturesNV, VkPhysicalDeviceInlineUniformBlockFeatures, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI, VkPhysicalDeviceLegacyDitheringFeaturesEXT, VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT, VkPhysicalDeviceLineRasterizationFeatures, VkPhysicalDeviceLinearColorAttachmentFeaturesNV, VkPhysicalDeviceMaintenance4Features, VkPhysicalDeviceMaintenance5Features, VkPhysicalDeviceMaintenance6Features, VkPhysicalDeviceMaintenance7FeaturesKHR, VkPhysicalDeviceMaintenance8FeaturesKHR, VkPhysicalDeviceMapMemoryPlacedFeaturesEXT, VkPhysicalDeviceMemoryDecompressionFeaturesNV, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiDrawFeaturesEXT, VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT, VkPhysicalDeviceNestedCommandBufferFeaturesEXT, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT, VkPhysicalDeviceOpacityMicromapFeaturesEXT, VkPhysicalDeviceOpticalFlowFeaturesNV, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV, VkPhysicalDevicePerStageDescriptorSetFeaturesNV, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePipelineBinaryFeaturesKHR, VkPhysicalDevicePipelineCreationCacheControlFeatures, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, VkPhysicalDevicePipelineOpacityMicromapFeaturesARM, VkPhysicalDevicePipelinePropertiesFeaturesEXT, VkPhysicalDevicePipelineProtectedAccessFeatures, VkPhysicalDevicePipelineRobustnessFeatures, VkPhysicalDevicePortabilitySubsetFeaturesKHR, VkPhysicalDevicePresentBarrierFeaturesNV, VkPhysicalDevicePresentIdFeaturesKHR, VkPhysicalDevicePresentMeteringFeaturesNV, VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT, VkPhysicalDevicePresentWaitFeaturesKHR, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, VkPhysicalDevicePrivateDataFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceProvokingVertexFeaturesEXT, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, VkPhysicalDeviceRawAccessChainsFeaturesNV, VkPhysicalDeviceRayQueryFeaturesKHR, VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV, VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV, VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV, VkPhysicalDeviceRayTracingPipelineFeaturesKHR, VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR, VkPhysicalDeviceRayTracingValidationFeaturesNV, VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG, VkPhysicalDeviceRenderPassStripedFeaturesARM, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceRobustness2FeaturesEXT, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceSchedulingControlsFeaturesARM, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderBfloat16FeaturesKHR, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, VkPhysicalDeviceShaderEnqueueFeaturesAMDX, VkPhysicalDeviceShaderExpectAssumeFeatures, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceShaderFloatControls2Features, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerDotProductFeatures, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT, VkPhysicalDeviceShaderObjectFeaturesEXT, VkPhysicalDeviceShaderQuadControlFeaturesKHR, VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR, VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceShaderSubgroupRotateFeatures, VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, VkPhysicalDeviceShaderTerminateInvocationFeatures, VkPhysicalDeviceShaderTileImageFeaturesEXT, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeatures, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI, VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT, VkPhysicalDeviceSynchronization2Features, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeatures, VkPhysicalDeviceTilePropertiesFeaturesQCOM, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeatures, VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, VkPhysicalDeviceVideoEncodeAV1FeaturesKHR, VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR, VkPhysicalDeviceVideoMaintenance1FeaturesKHR, VkPhysicalDeviceVideoMaintenance2FeaturesKHR, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan12Features, VkPhysicalDeviceVulkan13Features, VkPhysicalDeviceVulkan14Features, VkPhysicalDeviceVulkanMemoryModelFeatures, VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, VkPhysicalDeviceYcbcrDegammaFeaturesQCOM, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT, or VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures", + "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceDeviceMemoryReportCreateInfoEXT, VkDeviceDiagnosticsConfigCreateInfoNV, VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkDevicePipelineBinaryInternalCacheControlKHR, VkDevicePrivateDataCreateInfo, VkDeviceQueueShaderCoreControlCreateInfoARM, VkExternalComputeQueueDeviceCreateInfoNV, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice4444FormatsFeaturesEXT, VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceAccelerationStructureFeaturesKHR, VkPhysicalDeviceAddressBindingReportFeaturesEXT, VkPhysicalDeviceAmigoProfilingFeaturesSEC, VkPhysicalDeviceAntiLagFeaturesAMD, VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeatures, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceClusterAccelerationStructureFeaturesNV, VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceColorWriteEnableFeaturesEXT, VkPhysicalDeviceCommandBufferInheritanceFeaturesNV, VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrix2FeaturesNV, VkPhysicalDeviceCooperativeMatrixFeaturesKHR, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCooperativeVectorFeaturesNV, VkPhysicalDeviceCopyMemoryIndirectFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceCubicClampFeaturesQCOM, VkPhysicalDeviceCubicWeightsFeaturesQCOM, VkPhysicalDeviceCudaKernelLaunchFeaturesNV, VkPhysicalDeviceCustomBorderColorFeaturesEXT, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthBiasControlFeaturesEXT, VkPhysicalDeviceDepthClampControlFeaturesEXT, VkPhysicalDeviceDepthClampZeroOneFeaturesKHR, VkPhysicalDeviceDepthClipControlFeaturesEXT, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorBufferFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV, VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, VkPhysicalDeviceDiagnosticsConfigFeaturesNV, VkPhysicalDeviceDisplacementMicromapFeaturesNV, VkPhysicalDeviceDynamicRenderingFeatures, VkPhysicalDeviceDynamicRenderingLocalReadFeatures, VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV, VkPhysicalDeviceExternalFormatResolveFeaturesANDROID, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV, VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX, VkPhysicalDeviceFaultFeaturesEXT, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, VkPhysicalDeviceFragmentShadingRateFeaturesKHR, VkPhysicalDeviceFrameBoundaryFeaturesEXT, VkPhysicalDeviceGlobalPriorityQueryFeatures, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, VkPhysicalDeviceHdrVividFeaturesHUAWEI, VkPhysicalDeviceHostImageCopyFeatures, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT, VkPhysicalDeviceImageAlignmentControlFeaturesMESA, VkPhysicalDeviceImageCompressionControlFeaturesEXT, VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, VkPhysicalDeviceImageProcessing2FeaturesQCOM, VkPhysicalDeviceImageProcessingFeaturesQCOM, VkPhysicalDeviceImageRobustnessFeatures, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT, VkPhysicalDeviceImageViewMinLodFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceIndexTypeUint8Features, VkPhysicalDeviceInheritedViewportScissorFeaturesNV, VkPhysicalDeviceInlineUniformBlockFeatures, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI, VkPhysicalDeviceLegacyDitheringFeaturesEXT, VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT, VkPhysicalDeviceLineRasterizationFeatures, VkPhysicalDeviceLinearColorAttachmentFeaturesNV, VkPhysicalDeviceMaintenance4Features, VkPhysicalDeviceMaintenance5Features, VkPhysicalDeviceMaintenance6Features, VkPhysicalDeviceMaintenance7FeaturesKHR, VkPhysicalDeviceMaintenance8FeaturesKHR, VkPhysicalDeviceMapMemoryPlacedFeaturesEXT, VkPhysicalDeviceMemoryDecompressionFeaturesNV, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiDrawFeaturesEXT, VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT, VkPhysicalDeviceNestedCommandBufferFeaturesEXT, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT, VkPhysicalDeviceOpacityMicromapFeaturesEXT, VkPhysicalDeviceOpticalFlowFeaturesNV, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV, VkPhysicalDevicePerStageDescriptorSetFeaturesNV, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePipelineBinaryFeaturesKHR, VkPhysicalDevicePipelineCreationCacheControlFeatures, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, VkPhysicalDevicePipelineOpacityMicromapFeaturesARM, VkPhysicalDevicePipelinePropertiesFeaturesEXT, VkPhysicalDevicePipelineProtectedAccessFeatures, VkPhysicalDevicePipelineRobustnessFeatures, VkPhysicalDevicePortabilitySubsetFeaturesKHR, VkPhysicalDevicePresentBarrierFeaturesNV, VkPhysicalDevicePresentIdFeaturesKHR, VkPhysicalDevicePresentMeteringFeaturesNV, VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT, VkPhysicalDevicePresentWaitFeaturesKHR, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, VkPhysicalDevicePrivateDataFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceProvokingVertexFeaturesEXT, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, VkPhysicalDeviceRawAccessChainsFeaturesNV, VkPhysicalDeviceRayQueryFeaturesKHR, VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV, VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV, VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV, VkPhysicalDeviceRayTracingPipelineFeaturesKHR, VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR, VkPhysicalDeviceRayTracingValidationFeaturesNV, VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG, VkPhysicalDeviceRenderPassStripedFeaturesARM, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceRobustness2FeaturesEXT, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceSchedulingControlsFeaturesARM, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderBfloat16FeaturesKHR, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, VkPhysicalDeviceShaderEnqueueFeaturesAMDX, VkPhysicalDeviceShaderExpectAssumeFeatures, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceShaderFloatControls2Features, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerDotProductFeatures, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT, VkPhysicalDeviceShaderObjectFeaturesEXT, VkPhysicalDeviceShaderQuadControlFeaturesKHR, VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR, VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceShaderSubgroupRotateFeatures, VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, VkPhysicalDeviceShaderTerminateInvocationFeatures, VkPhysicalDeviceShaderTileImageFeaturesEXT, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeatures, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI, VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT, VkPhysicalDeviceSynchronization2Features, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeatures, VkPhysicalDeviceTilePropertiesFeaturesQCOM, VkPhysicalDeviceTileShadingFeaturesQCOM, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeatures, VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, VkPhysicalDeviceVideoEncodeAV1FeaturesKHR, VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR, VkPhysicalDeviceVideoMaintenance1FeaturesKHR, VkPhysicalDeviceVideoMaintenance2FeaturesKHR, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan12Features, VkPhysicalDeviceVulkan13Features, VkPhysicalDeviceVulkan14Features, VkPhysicalDeviceVulkanMemoryModelFeatures, VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, VkPhysicalDeviceYcbcrDegammaFeaturesQCOM, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT, or VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures", "page": "chapters/devsandqueues.html" }, { @@ -1598,6 +1598,21 @@ "text": "If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT and the renderPass member of pInheritanceInfo is not VK_NULL_HANDLE, the subpass member of pInheritanceInfo must be a valid subpass index within the renderPass member of pInheritanceInfo", "page": "chapters/cmdbuffers.html" }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-10617", + "text": "If flags contains VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT , the renderPass member of pInheritanceInfo is not VK_NULL_HANDLE, and renderPass was created with tile shading enabled, VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM must be included in VkRenderPassTileShadingCreateInfoQCOM::flags", + "page": "chapters/cmdbuffers.html" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-10618", + "text": "If flags does not contain VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT , the renderPass member of pInheritanceInfo is VK_NULL_HANDLE, or renderPass was not created with tile shading enabled, VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM must not be included in VkRenderPassTileShadingCreateInfoQCOM::flags", + "page": "chapters/cmdbuffers.html" + }, + { + "vuid": "VUID-VkCommandBufferBeginInfo-flags-10619", + "text": "If VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM is included in VkRenderPassTileShadingCreateInfoQCOM::flags, VkRenderPassTileShadingCreateInfoQCOM::tileApronSize must be equal to the tileApronSize used to create renderPass", + "page": "chapters/cmdbuffers.html" + }, { "vuid": "VUID-VkCommandBufferBeginInfo-sType-sType", "text": "sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO", @@ -1654,7 +1669,7 @@ }, { "vuid": "VUID-VkCommandBufferInheritanceInfo-pNext-pNext", - "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkAttachmentSampleCountInfoAMD, VkCommandBufferInheritanceConditionalRenderingInfoEXT, VkCommandBufferInheritanceRenderPassTransformInfoQCOM, VkCommandBufferInheritanceRenderingInfo, VkCommandBufferInheritanceViewportScissorInfoNV, VkExternalFormatANDROID, VkMultiviewPerViewAttributesInfoNVX, VkRenderingAttachmentLocationInfo, or VkRenderingInputAttachmentIndexInfo", + "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkAttachmentSampleCountInfoAMD, VkCommandBufferInheritanceConditionalRenderingInfoEXT, VkCommandBufferInheritanceRenderPassTransformInfoQCOM, VkCommandBufferInheritanceRenderingInfo, VkCommandBufferInheritanceViewportScissorInfoNV, VkExternalFormatANDROID, VkMultiviewPerViewAttributesInfoNVX, VkRenderPassTileShadingCreateInfoQCOM, VkRenderingAttachmentLocationInfo, or VkRenderingInputAttachmentIndexInfo", "page": "chapters/cmdbuffers.html" }, { @@ -2996,6 +3011,36 @@ "text": "If vkCmdExecuteCommands is being called within a render pass instance begun with vkCmdBeginRendering, the input attachment mapping state specified by VkRenderingInputAttachmentIndexInfo in the inheritance info of each element of pCommandBuffers and in the current state of commandBuffer must match", "page": "chapters/cmdbuffers.html" }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-10620", + "text": "If this command is being recorded within a render pass instance with tile shading enabled, all elements of pCommandBuffers must have been recorded with VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM included in VkRenderPassTileShadingCreateInfoQCOM::flags", + "page": "chapters/cmdbuffers.html" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-10621", + "text": "If the per-tile execution model is enabled, all elements of pCommandBuffers must have been recorded with VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM included in VkRenderPassTileShadingCreateInfoQCOM::flags", + "page": "chapters/cmdbuffers.html" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-tileApronSize-10622", + "text": "If this command is being recorded within a render pass instance, the tileApronSize used to create the render pass instance must equal the VkRenderPassTileShadingCreateInfoQCOM::tileApronSize used to record all elements of pCommandBuffers", + "page": "chapters/cmdbuffers.html" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-10623", + "text": "If any element of pCommandBuffers was recorded with VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM included in VkRenderPassTileShadingCreateInfoQCOM::flags, this command must be recorded in a render pass that has tile shading enabled", + "page": "chapters/cmdbuffers.html" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-pCommandBuffers-10624", + "text": "If any element of pCommandBuffers was recorded with VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM included in VkRenderPassTileShadingCreateInfoQCOM::flags, per-tile execution model must be enabled", + "page": "chapters/cmdbuffers.html" + }, + { + "vuid": "VUID-vkCmdExecuteCommands-tileApronSize-10625", + "text": "If this command is not being recorded into a render pass instance, the VkRenderPassTileShadingCreateInfoQCOM::tileApronSize that was recorded into all elements of pCommandBuffers must equal (0,0)", + "page": "chapters/cmdbuffers.html" + }, { "vuid": "VUID-vkCmdExecuteCommands-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -5142,6 +5187,11 @@ "text": "If the maintenance8 feature is not enabled, The dependencyFlags members of any element of pDependencyInfos must not include VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR", "page": "chapters/synchronization.html" }, + { + "vuid": "VUID-vkCmdWaitEvents2-None-10654", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/synchronization.html" + }, { "vuid": "VUID-vkCmdWaitEvents2-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -5356,6 +5406,11 @@ "text": "Elements of pEvents must not have been signaled by vkCmdSetEvent2", "page": "chapters/synchronization.html" }, + { + "vuid": "VUID-vkCmdWaitEvents-None-10655", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/synchronization.html" + }, { "vuid": "VUID-vkCmdWaitEvents-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -6118,6 +6173,16 @@ "text": "If srcAccessMask includes VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT, srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, or one of VK_PIPELINE_STAGE_*_SHADER_BIT stages", "page": "chapters/synchronization.html" }, + { + "vuid": "VUID-VkMemoryBarrier2-srcAccessMask-10670", + "text": "If srcAccessMask includes VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM, srcStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT or VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT.", + "page": "chapters/synchronization.html" + }, + { + "vuid": "VUID-VkMemoryBarrier2-srcAccessMask-10671", + "text": "If srcAccessMask includes VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM, srcStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT or VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT.", + "page": "chapters/synchronization.html" + }, { "vuid": "VUID-VkMemoryBarrier2-dstStageMask-03929", "text": "If the geometryShader feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT", @@ -6378,6 +6443,16 @@ "text": "If dstAccessMask includes VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT, dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, or one of VK_PIPELINE_STAGE_*_SHADER_BIT stages", "page": "chapters/synchronization.html" }, + { + "vuid": "VUID-VkMemoryBarrier2-dstAccessMask-10670", + "text": "If dstAccessMask includes VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM, dstStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT or VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT.", + "page": "chapters/synchronization.html" + }, + { + "vuid": "VUID-VkMemoryBarrier2-dstAccessMask-10671", + "text": "If dstAccessMask includes VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM, dstStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT or VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT.", + "page": "chapters/synchronization.html" + }, { "vuid": "VUID-VkMemoryBarrier2-sType-sType", "text": "sType must be VK_STRUCTURE_TYPE_MEMORY_BARRIER_2", @@ -6691,6 +6766,16 @@ "text": "If srcAccessMask includes VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT, srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, or one of VK_PIPELINE_STAGE_*_SHADER_BIT stages", "page": "chapters/synchronization.html" }, + { + "vuid": "VUID-VkBufferMemoryBarrier2-srcAccessMask-10670", + "text": "If srcAccessMask includes VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM, srcStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT or VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT.", + "page": "chapters/synchronization.html" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2-srcAccessMask-10671", + "text": "If srcAccessMask includes VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM, srcStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT or VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT.", + "page": "chapters/synchronization.html" + }, { "vuid": "VUID-VkBufferMemoryBarrier2-dstStageMask-03929", "text": "If the geometryShader feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT", @@ -6951,6 +7036,16 @@ "text": "If dstAccessMask includes VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT, dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, or one of VK_PIPELINE_STAGE_*_SHADER_BIT stages", "page": "chapters/synchronization.html" }, + { + "vuid": "VUID-VkBufferMemoryBarrier2-dstAccessMask-10670", + "text": "If dstAccessMask includes VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM, dstStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT or VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT.", + "page": "chapters/synchronization.html" + }, + { + "vuid": "VUID-VkBufferMemoryBarrier2-dstAccessMask-10671", + "text": "If dstAccessMask includes VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM, dstStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT or VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT.", + "page": "chapters/synchronization.html" + }, { "vuid": "VUID-VkBufferMemoryBarrier2-offset-01187", "text": "offset must be less than the size of buffer", @@ -7399,6 +7494,16 @@ "text": "If srcAccessMask includes VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT, srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, or one of VK_PIPELINE_STAGE_*_SHADER_BIT stages", "page": "chapters/synchronization.html" }, + { + "vuid": "VUID-VkImageMemoryBarrier2-srcAccessMask-10670", + "text": "If srcAccessMask includes VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM, srcStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT or VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT.", + "page": "chapters/synchronization.html" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2-srcAccessMask-10671", + "text": "If srcAccessMask includes VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM, srcStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT or VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT.", + "page": "chapters/synchronization.html" + }, { "vuid": "VUID-VkImageMemoryBarrier2-dstStageMask-03929", "text": "If the geometryShader feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT", @@ -7659,6 +7764,16 @@ "text": "If dstAccessMask includes VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT, dstStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, or one of VK_PIPELINE_STAGE_*_SHADER_BIT stages", "page": "chapters/synchronization.html" }, + { + "vuid": "VUID-VkImageMemoryBarrier2-dstAccessMask-10670", + "text": "If dstAccessMask includes VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM, dstStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT or VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT.", + "page": "chapters/synchronization.html" + }, + { + "vuid": "VUID-VkImageMemoryBarrier2-dstAccessMask-10671", + "text": "If dstAccessMask includes VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM, dstStageMask must include VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT or VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT.", + "page": "chapters/synchronization.html" + }, { "vuid": "VUID-VkImageMemoryBarrier2-oldLayout-01208", "text": "If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT", @@ -8550,6 +8665,16 @@ "text": "For any element of pRenderingInfo->pColorAttachments, if either imageResolveMode is VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID, or imageView is not VK_NULL_HANDLE and resolveMode is not VK_RESOLVE_MODE_NONE, and resolveImageView is not VK_NULL_HANDLE, resolveImageView must be in the layout specified by resolveImageLayout", "page": "chapters/renderpass.html" }, + { + "vuid": "VUID-vkCmdBeginRendering-flags-10641", + "text": "If VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM is included in VkRenderPassTileShadingCreateInfoQCOM::flags, commandBuffer must not have been created with VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdBeginRendering-flags-10642", + "text": "VkRenderPassTileShadingCreateInfoQCOM::flags must not include VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM", + "page": "chapters/renderpass.html" + }, { "vuid": "VUID-vkCmdBeginRendering-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -8999,6 +9124,16 @@ "text": "If the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, it must have been created with the identity swizzle", "page": "chapters/renderpass.html" }, + { + "vuid": "VUID-VkRenderingInfo-imageView-10643", + "text": "If the imageView member of a VkRenderingFragmentDensityMapAttachmentInfoEXT structure included in the pNext chain is not VK_NULL_HANDLE, VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM must not be included in VkRenderPassTileShadingCreateInfoQCOM::flags", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-VkRenderingInfo-resolveMode-10644", + "text": "If the resolveMode of any element of pColorAttachments is VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID, VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM must not be included in VkRenderPassTileShadingCreateInfoQCOM::flags", + "page": "chapters/renderpass.html" + }, { "vuid": "VUID-VkRenderingInfo-sType-sType", "text": "sType must be VK_STRUCTURE_TYPE_RENDERING_INFO", @@ -9006,7 +9141,7 @@ }, { "vuid": "VUID-VkRenderingInfo-pNext-pNext", - "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupRenderPassBeginInfo, VkMultisampledRenderToSingleSampledInfoEXT, VkMultiviewPerViewAttributesInfoNVX, VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, VkRenderPassStripeBeginInfoARM, VkRenderingFragmentDensityMapAttachmentInfoEXT, or VkRenderingFragmentShadingRateAttachmentInfoKHR", + "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupRenderPassBeginInfo, VkMultisampledRenderToSingleSampledInfoEXT, VkMultiviewPerViewAttributesInfoNVX, VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM, VkRenderPassStripeBeginInfoARM, VkRenderPassTileShadingCreateInfoQCOM, VkRenderingFragmentDensityMapAttachmentInfoEXT, or VkRenderingFragmentShadingRateAttachmentInfoKHR", "page": "chapters/renderpass.html" }, { @@ -9456,6 +9591,11 @@ "text": "If vkCmdBeginQuery* was called within the render pass, the corresponding vkCmdEndQuery* must have been called subsequently within the same subpass", "page": "chapters/renderpass.html" }, + { + "vuid": "VUID-vkCmdEndRendering-None-10645", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/renderpass.html" + }, { "vuid": "VUID-vkCmdEndRendering-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -9596,6 +9736,11 @@ "text": "device must support at least one queue family with the VK_QUEUE_GRAPHICS_BIT capability", "page": "chapters/renderpass.html" }, + { + "vuid": "VUID-vkCreateRenderPass-flags-10646", + "text": "VkRenderPassTileShadingCreateInfoQCOM::flags must not include VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM", + "page": "chapters/renderpass.html" + }, { "vuid": "VUID-vkCreateRenderPass-device-parameter", "text": "device must be a valid VkDevice handle", @@ -9720,6 +9865,16 @@ "text": "For any element of pDependencies, if its dstSubpass is not VK_SUBPASS_EXTERNAL, it must be less than subpassCount", "page": "chapters/renderpass.html" }, + { + "vuid": "VUID-VkRenderPassCreateInfo-pResolveAttachments-10647", + "text": "If any element of pResolveAttachments of any element of pSubpasses references an attachment description with a format of VK_FORMAT_UNDEFINED, VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM must not be included in VkRenderPassTileShadingCreateInfoQCOM::flags", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo-fragmentDensityMapAttachment-10648", + "text": "If VkRenderPassFragmentDensityMapCreateInfoEXT::fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM must not be included in VkRenderPassTileShadingCreateInfoQCOM::flags", + "page": "chapters/renderpass.html" + }, { "vuid": "VUID-VkRenderPassCreateInfo-sType-sType", "text": "sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO", @@ -9727,7 +9882,7 @@ }, { "vuid": "VUID-VkRenderPassCreateInfo-pNext-pNext", - "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkRenderPassFragmentDensityMapCreateInfoEXT, VkRenderPassInputAttachmentAspectCreateInfo, or VkRenderPassMultiviewCreateInfo", + "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkRenderPassFragmentDensityMapCreateInfoEXT, VkRenderPassInputAttachmentAspectCreateInfo, VkRenderPassMultiviewCreateInfo, or VkRenderPassTileShadingCreateInfoQCOM", "page": "chapters/renderpass.html" }, { @@ -10143,6 +10298,11 @@ "text": "If the attachment member of an element of pResolveAttachments is not VK_ATTACHMENT_UNUSED, its layout member must not be VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR", "page": "chapters/renderpass.html" }, + { + "vuid": "VUID-VkSubpassDescription-flags-10683", + "text": "If flags includes VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM, the render pass must have been created with a VkRenderPassTileShadingCreateInfoQCOM::tileApronSize greater than (0,0)", + "page": "chapters/renderpass.html" + }, { "vuid": "VUID-VkSubpassDescription-pipelineBindPoint-04952", "text": "pipelineBindPoint must be VK_PIPELINE_BIND_POINT_GRAPHICS or VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI", @@ -10569,6 +10729,11 @@ "text": "device must support at least one queue family with the VK_QUEUE_GRAPHICS_BIT capability", "page": "chapters/renderpass.html" }, + { + "vuid": "VUID-vkCreateRenderPass2-flags-10649", + "text": "VkRenderPassTileShadingCreateInfoQCOM::flags must not include VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM", + "page": "chapters/renderpass.html" + }, { "vuid": "VUID-vkCreateRenderPass2-device-parameter", "text": "device must be a valid VkDevice handle", @@ -10743,6 +10908,16 @@ "text": "If any element of pResolveAttachments of any element of pSubpasses references an attachment description with a format of VK_FORMAT_UNDEFINED, VkRenderPassFragmentDensityMapCreateInfoEXT::fragmentDensityMapAttachment->attachment must be VK_ATTACHMENT_UNUSED", "page": "chapters/renderpass.html" }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-pResolveAttachments-10650", + "text": "If any element of pResolveAttachments of any element of pSubpasses references an attachment description with a format of VK_FORMAT_UNDEFINED, VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM must not be included in VkRenderPassTileShadingCreateInfoQCOM::flags", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-VkRenderPassCreateInfo2-fragmentDensityMapAttachment-10651", + "text": "If VkRenderPassFragmentDensityMapCreateInfoEXT::fragmentDensityMapAttachment is not VK_ATTACHMENT_UNUSED, VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM must not be included in VkRenderPassTileShadingCreateInfoQCOM::flags", + "page": "chapters/renderpass.html" + }, { "vuid": "VUID-VkRenderPassCreateInfo2-sType-sType", "text": "sType must be VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2", @@ -10750,7 +10925,7 @@ }, { "vuid": "VUID-VkRenderPassCreateInfo2-pNext-pNext", - "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkRenderPassCreationControlEXT, VkRenderPassCreationFeedbackCreateInfoEXT, or VkRenderPassFragmentDensityMapCreateInfoEXT", + "text": "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkRenderPassCreationControlEXT, VkRenderPassCreationFeedbackCreateInfoEXT, VkRenderPassFragmentDensityMapCreateInfoEXT, or VkRenderPassTileShadingCreateInfoQCOM", "page": "chapters/renderpass.html" }, { @@ -11105,6 +11280,11 @@ "text": "If the attachment member of an element of pResolveAttachments is not VK_ATTACHMENT_UNUSED, its layout member must not be VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR", "page": "chapters/renderpass.html" }, + { + "vuid": "VUID-VkSubpassDescription2-flags-10683", + "text": "If flags includes VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM, the render pass must have been created with a VkRenderPassTileShadingCreateInfoQCOM::tileApronSize greater than (0,0)", + "page": "chapters/renderpass.html" + }, { "vuid": "VUID-VkSubpassDescription2-attachment-06251", "text": "If the attachment member of pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and its pNext chain includes a VkAttachmentReferenceStencilLayout structure, the layout member of pDepthStencilAttachment must not be VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL", @@ -12476,6 +12656,11 @@ "text": "If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including either VK_IMAGE_USAGE_STORAGE_BIT, or both VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT and either of VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT or VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", "page": "chapters/renderpass.html" }, + { + "vuid": "VUID-vkCmdBeginRenderPass2-flags-10652", + "text": "If VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM was included in the VkRenderPassTileShadingCreateInfoQCOM::flags used to create the renderPass, commandBuffer must not have been created with VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT", + "page": "chapters/renderpass.html" + }, { "vuid": "VUID-vkCmdBeginRenderPass2-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -13083,6 +13268,11 @@ "text": "If vkCmdBeginQuery* was called within a subpass of the render pass, the corresponding vkCmdEndQuery* must have been called subsequently within the same subpass", "page": "chapters/renderpass.html" }, + { + "vuid": "VUID-vkCmdEndRenderPass-None-10653", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/renderpass.html" + }, { "vuid": "VUID-vkCmdEndRenderPass-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -13299,6 +13489,166 @@ } ] }, + "VkRenderPassTileShadingCreateInfoQCOM": { + "core": [ + { + "vuid": "VUID-VkRenderPassTileShadingCreateInfoQCOM-tileShading-10658", + "text": "If the tileShading feature is not enabled, VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM must not be included in flags", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-VkRenderPassTileShadingCreateInfoQCOM-flags-10659", + "text": "If VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM is not included in flags or the tileShadingApron feature is not enabled, tileApronSize must be (0,0)", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-VkRenderPassTileShadingCreateInfoQCOM-flags-10660", + "text": "If VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM is not included in flags, or neither the tileShadingPerTileDispatch and tileShadingPerTileDraw features are enabled, flags must not include VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-VkRenderPassTileShadingCreateInfoQCOM-tileShadingAnisotropicApron-10661", + "text": "If the tileShadingAnisotropicApron feature is not enabled, tileApronSize.x and must be equal to tileApronSize.y", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-VkRenderPassTileShadingCreateInfoQCOM-tileApronSize-10662", + "text": "tileApronSize.x must be less than or equal to maxApronSize", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-VkRenderPassTileShadingCreateInfoQCOM-tileApronSize-10663", + "text": "tileApronSize.y must be less than or equal to maxApronSize", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-VkRenderPassTileShadingCreateInfoQCOM-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-VkRenderPassTileShadingCreateInfoQCOM-flags-parameter", + "text": "flags must be a valid combination of VkTileShadingRenderPassFlagBitsQCOM values", + "page": "chapters/renderpass.html" + } + ] + }, + "vkCmdBeginPerTileExecutionQCOM": { + "core": [ + { + "vuid": "VUID-vkCmdBeginPerTileExecutionQCOM-None-10664", + "text": "The current render pass must be a tile shading render pass", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdBeginPerTileExecutionQCOM-None-10665", + "text": "The tileShadingPerTileDispatch or tileShadingPerTileDraw feature must be enabled", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdBeginPerTileExecutionQCOM-commandBuffer-parameter", + "text": "commandBuffer must be a valid VkCommandBuffer handle", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdBeginPerTileExecutionQCOM-pPerTileBeginInfo-parameter", + "text": "pPerTileBeginInfo must be a valid pointer to a valid VkPerTileBeginInfoQCOM structure", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdBeginPerTileExecutionQCOM-commandBuffer-recording", + "text": "commandBuffer must be in the recording state", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdBeginPerTileExecutionQCOM-commandBuffer-cmdpool", + "text": "The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdBeginPerTileExecutionQCOM-renderpass", + "text": "This command must only be called inside of a render pass instance", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdBeginPerTileExecutionQCOM-videocoding", + "text": "This command must only be called outside of a video coding scope", + "page": "chapters/renderpass.html" + } + ] + }, + "VkPerTileBeginInfoQCOM": { + "core": [ + { + "vuid": "VUID-VkPerTileBeginInfoQCOM-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-VkPerTileBeginInfoQCOM-pNext-pNext", + "text": "pNext must be NULL", + "page": "chapters/renderpass.html" + } + ] + }, + "vkCmdEndPerTileExecutionQCOM": { + "core": [ + { + "vuid": "VUID-vkCmdEndPerTileExecutionQCOM-None-10666", + "text": "The per-tile execution model must have been enabled in the current render pass", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdEndPerTileExecutionQCOM-None-10667", + "text": "The current render pass must be a tile shading render pass", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdEndPerTileExecutionQCOM-commandBuffer-parameter", + "text": "commandBuffer must be a valid VkCommandBuffer handle", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdEndPerTileExecutionQCOM-pPerTileEndInfo-parameter", + "text": "pPerTileEndInfo must be a valid pointer to a valid VkPerTileEndInfoQCOM structure", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdEndPerTileExecutionQCOM-commandBuffer-recording", + "text": "commandBuffer must be in the recording state", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdEndPerTileExecutionQCOM-commandBuffer-cmdpool", + "text": "The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdEndPerTileExecutionQCOM-renderpass", + "text": "This command must only be called inside of a render pass instance", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-vkCmdEndPerTileExecutionQCOM-videocoding", + "text": "This command must only be called outside of a video coding scope", + "page": "chapters/renderpass.html" + } + ] + }, + "VkPerTileEndInfoQCOM": { + "core": [ + { + "vuid": "VUID-VkPerTileEndInfoQCOM-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM", + "page": "chapters/renderpass.html" + }, + { + "vuid": "VUID-VkPerTileEndInfoQCOM-pNext-pNext", + "text": "pNext must be NULL", + "page": "chapters/renderpass.html" + } + ] + }, "vkCreateShadersEXT": { "core": [ { @@ -15504,6 +15854,21 @@ "text": "If the robustImageAccess2 feature is not supported, images must not be VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2", "page": "chapters/pipelines.html" }, + { + "vuid": "VUID-VkPipelineRobustnessCreateInfo-storageBuffers-10636", + "text": "If storageBuffers is VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2, and either descriptorBindingStorageBufferUpdateAfterBind or descriptorBindingStorageTexelBufferUpdateAfterBind is enabled on the device, robustBufferAccessUpdateAfterBind must be VK_TRUE", + "page": "chapters/pipelines.html" + }, + { + "vuid": "VUID-VkPipelineRobustnessCreateInfo-uniformBuffers-10637", + "text": "If uniformBuffers is VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2, and either descriptorBindingInlineUniformBlockUpdateAfterBind, descriptorBindingUniformBufferUpdateAfterBind or descriptorBindingUniformTexelBufferUpdateAfterBind is enabled on the device, robustBufferAccessUpdateAfterBind must be VK_TRUE", + "page": "chapters/pipelines.html" + }, + { + "vuid": "VUID-VkPipelineRobustnessCreateInfo-images-10638", + "text": "If images is VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS or VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2, and either descriptorBindingStorageImageUpdateAfterBind or descriptorBindingSampledImageUpdateAfterBind is enabled on the device, robustBufferAccessUpdateAfterBind must be VK_TRUE", + "page": "chapters/pipelines.html" + }, { "vuid": "VUID-VkPipelineRobustnessCreateInfo-sType-sType", "text": "sType must be VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO", @@ -34763,6 +35128,63 @@ } ] }, + "TileOffsetQCOM": { + "core": [ + { + "vuid": "VUID-TileOffsetQCOM-TileOffsetQCOM-10626", + "text": "The TileOffsetQCOM decoration must be used only within the Fragment Execution Model or GLCompute Execution Model.", + "page": "chapters/interfaces.html" + }, + { + "vuid": "VUID-TileOffsetQCOM-TileOffsetQCOM-10627", + "text": "The variable decorated with TileOffsetQCOM must be declared using the Input Storage Class", + "page": "chapters/interfaces.html" + }, + { + "vuid": "VUID-TileOffsetQCOM-TileOffsetQCOM-10628", + "text": "The variable decorated with TileOffsetQCOM must be declared as a two-component vector of 32-bit integer values", + "page": "chapters/interfaces.html" + } + ] + }, + "TileDimensionQCOM": { + "core": [ + { + "vuid": "VUID-TileDimensionQCOM-TileDimensionQCOM-10629", + "text": "The TileDimensionQCOM decoration must be used only within the Fragment Execution Model or GLCompute Execution Model.", + "page": "chapters/interfaces.html" + }, + { + "vuid": "VUID-TileDimensionQCOM-TileDimensionQCOM-10630", + "text": "The variable decorated with TileDimensionQCOM must be declared using the Input Storage Class", + "page": "chapters/interfaces.html" + }, + { + "vuid": "VUID-TileDimensionQCOM-TileDimensionQCOM-10631", + "text": "The variable decorated with TileDimensionQCOM must be declared as a two-component vector of 32-bit integer values", + "page": "chapters/interfaces.html" + } + ] + }, + "TileApronSizeQCOM": { + "core": [ + { + "vuid": "VUID-TileApronSizeQCOM-TileApronSizeQCOM-10632", + "text": "The TileApronSizeQCOM decoration must be used only within the Fragment Execution Model or GLCompute Execution Model.", + "page": "chapters/interfaces.html" + }, + { + "vuid": "VUID-TileApronSizeQCOM-TileApronSizeQCOM-10633", + "text": "The variable decorated with TileApronSizeQCOM must be declared using the Input Storage Class", + "page": "chapters/interfaces.html" + }, + { + "vuid": "VUID-TileApronSizeQCOM-TileApronSizeQCOM-10634", + "text": "The variable decorated with TileApronSizeQCOM must be declared as a two-component vector of 32-bit integer values", + "page": "chapters/interfaces.html" + } + ] + }, "VertexCountHUAWEI": { "core": [ { @@ -34994,6 +35416,11 @@ "vuid": "VUID-WorkgroupSize-WorkgroupSize-04427", "text": "The variable decorated with WorkgroupSize must be declared as a three-component vector of 32-bit integer values", "page": "chapters/interfaces.html" + }, + { + "vuid": "VUID-WorkgroupSize-TileShadingRateQCOM-10635", + "text": "If the TileShadingRateQCOM Execution Mode is used, variables decorated withWorkgroupSize must be declared using the Input Storage Class", + "page": "chapters/interfaces.html" } ] }, @@ -35695,6 +36122,11 @@ "text": "If the queryType used to create queryPool was not VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR or VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR, then there must be no bound video session", "page": "chapters/queries.html" }, + { + "vuid": "VUID-vkCmdBeginQuery-None-10681", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/queries.html" + }, { "vuid": "VUID-vkCmdBeginQuery-queryPool-01922", "text": "queryPool must have been created with a queryType that differs from that of any queries that are active within commandBuffer", @@ -35884,6 +36316,11 @@ "text": "If the queryType used to create queryPool was not VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR or VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR, then there must be no bound video session", "page": "chapters/queries.html" }, + { + "vuid": "VUID-vkCmdBeginQueryIndexedEXT-None-10681", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/queries.html" + }, { "vuid": "VUID-vkCmdBeginQueryIndexedEXT-queryPool-04753", "text": "If the queryPool was created with the same queryType as that of another active query within commandBuffer, then index must not match the index used for the active query", @@ -36038,6 +36475,11 @@ "text": "If called within a subpass of a render pass instance, the corresponding vkCmdBeginQuery* command must have been called previously within the same subpass", "page": "chapters/queries.html" }, + { + "vuid": "VUID-vkCmdEndQuery-None-10682", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/queries.html" + }, { "vuid": "VUID-vkCmdEndQuery-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -36107,6 +36549,11 @@ "text": "If called within a subpass of a render pass instance, the corresponding vkCmdBeginQuery* command must have been called previously within the same subpass", "page": "chapters/queries.html" }, + { + "vuid": "VUID-vkCmdEndQueryIndexedEXT-None-10682", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/queries.html" + }, { "vuid": "VUID-vkCmdEndQueryIndexedEXT-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -36489,6 +36936,11 @@ "text": "If vkCmdWriteTimestamp2 is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool", "page": "chapters/queries.html" }, + { + "vuid": "VUID-vkCmdWriteTimestamp2-None-10639", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/queries.html" + }, { "vuid": "VUID-vkCmdWriteTimestamp2-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -36603,6 +37055,11 @@ "text": "If vkCmdWriteTimestamp is called within a render pass instance, the sum of query and the number of bits set in the current subpass’s view mask must be less than or equal to the number of queries in queryPool", "page": "chapters/queries.html" }, + { + "vuid": "VUID-vkCmdWriteTimestamp-None-10640", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/queries.html" + }, { "vuid": "VUID-vkCmdWriteTimestamp-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -37346,6 +37803,11 @@ "text": "If the attachment format has components other than R and G, it must not have a 64-bit component width", "page": "chapters/clears.html" }, + { + "vuid": "VUID-vkCmdClearAttachments-None-10616", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/clears.html" + }, { "vuid": "VUID-vkCmdClearAttachments-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -38021,16 +38483,6 @@ "text": "If dstImage has a multi-planar format and the srcImage does not have a multi-planar image format, then for each element of pRegions, srcSubresource.aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT", "page": "chapters/copies.html" }, - { - "vuid": "VUID-vkCmdCopyImage-srcSubresource-10209", - "text": "If srcSubresource.aspectMask is VK_IMAGE_ASPECT_COLOR_BIT and dstSubresource.aspectMask is VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT, then maintenance8 must be enabled", - "page": "chapters/copies.html" - }, - { - "vuid": "VUID-vkCmdCopyImage-srcSubresource-10210", - "text": "If srcSubresource.aspectMask is VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT and dstSubresource.aspectMask is VK_IMAGE_ASPECT_COLOR_BIT, then maintenance8 must be enabled", - "page": "chapters/copies.html" - }, { "vuid": "VUID-vkCmdCopyImage-srcSubresource-10211", "text": "If srcSubresource.aspectMask is VK_IMAGE_ASPECT_COLOR_BIT and dstSubresource.aspectMask is VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT, then the VkFormat values of srcImage and dstImage must be compatible according to the list of compatible depth-stencil and color formats", @@ -38592,16 +39044,6 @@ "text": "If dstImage has a multi-planar format and the srcImage does not have a multi-planar image format, then for each element of pRegions, srcSubresource.aspectMask must be VK_IMAGE_ASPECT_COLOR_BIT", "page": "chapters/copies.html" }, - { - "vuid": "VUID-VkCopyImageInfo2-srcSubresource-10209", - "text": "If srcSubresource.aspectMask is VK_IMAGE_ASPECT_COLOR_BIT and dstSubresource.aspectMask is VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT, then maintenance8 must be enabled", - "page": "chapters/copies.html" - }, - { - "vuid": "VUID-VkCopyImageInfo2-srcSubresource-10210", - "text": "If srcSubresource.aspectMask is VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT and dstSubresource.aspectMask is VK_IMAGE_ASPECT_COLOR_BIT, then maintenance8 must be enabled", - "page": "chapters/copies.html" - }, { "vuid": "VUID-VkCopyImageInfo2-srcSubresource-10211", "text": "If srcSubresource.aspectMask is VK_IMAGE_ASPECT_COLOR_BIT and dstSubresource.aspectMask is VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT, then the VkFormat values of srcImage and dstImage must be compatible according to the list of compatible depth-stencil and color formats", @@ -41821,12 +42263,12 @@ }, { "vuid": "VUID-vkCmdBlitImage-maintenance8-10579", - "text": "If the maintenance8 feature is enabled and srcImage is not of type VK_IMAGE_TYPE_3D, then for each element of pRegions, the absolute difference of the z member of each member of dstOffsets must equal srcSubresource.layerCount", + "text": "If the maintenance8 feature is enabled, dstImage is VK_IMAGE_TYPE_3D, and srcImage is not of type VK_IMAGE_TYPE_3D, then for each element of pRegions, the absolute difference of the z member of each member of dstOffsets must equal srcSubresource.layerCount", "page": "chapters/copies.html" }, { "vuid": "VUID-vkCmdBlitImage-maintenance8-10580", - "text": "If the maintenance8 feature is enabled and dstImage is not of type VK_IMAGE_TYPE_3D, then for each element of pRegions, the absolute difference of the z member of each member of srcOffsets must equal dstSubresource.layerCount", + "text": "If the maintenance8 feature is enabled, srcImage is VK_IMAGE_TYPE_3D, and dstImage is not of type VK_IMAGE_TYPE_3D, then for each element of pRegions, the absolute difference of the z member of each member of srcOffsets must equal dstSubresource.layerCount", "page": "chapters/copies.html" }, { @@ -42203,12 +42645,12 @@ }, { "vuid": "VUID-VkBlitImageInfo2-maintenance8-10579", - "text": "If the maintenance8 feature is enabled and srcImage is not of type VK_IMAGE_TYPE_3D, then for each element of pRegions, the absolute difference of the z member of each member of dstOffsets must equal srcSubresource.layerCount", + "text": "If the maintenance8 feature is enabled, dstImage is VK_IMAGE_TYPE_3D, and srcImage is not of type VK_IMAGE_TYPE_3D, then for each element of pRegions, the absolute difference of the z member of each member of dstOffsets must equal srcSubresource.layerCount", "page": "chapters/copies.html" }, { "vuid": "VUID-VkBlitImageInfo2-maintenance8-10580", - "text": "If the maintenance8 feature is enabled and dstImage is not of type VK_IMAGE_TYPE_3D, then for each element of pRegions, the absolute difference of the z member of each member of srcOffsets must equal dstSubresource.layerCount", + "text": "If the maintenance8 feature is enabled, srcImage is VK_IMAGE_TYPE_3D, and dstImage is not of type VK_IMAGE_TYPE_3D, then for each element of pRegions, the absolute difference of the z member of each member of srcOffsets must equal dstSubresource.layerCount", "page": "chapters/copies.html" }, { @@ -43691,11 +44133,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDraw-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDraw-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -43721,16 +44158,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDraw-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDraw-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDraw-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -43851,6 +44278,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDraw-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDraw-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDraw-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -44861,6 +45298,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDraw-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDraw-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDraw-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDraw-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDraw-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -44951,6 +45408,11 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDraw-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDraw-commandBuffer-02712", "text": "If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource", @@ -45071,26 +45533,6 @@ "text": "If a shader object is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage or a graphics pipeline is bound which was created with both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage and the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled, then vkCmdSetTessellationDomainOriginEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDraw-None-08684", - "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDraw-None-08685", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDraw-None-08686", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDraw-None-08687", - "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDraw-pNext-09461", "text": "If the bound graphics pipeline state was created with VkPipelineVertexInputDivisorStateCreateInfo in the pNext chain of VkGraphicsPipelineCreateInfo::pVertexInputState, any member of VkPipelineVertexInputDivisorStateCreateInfo::pVertexBindingDivisors has a value other than 1 in divisor, and VkPhysicalDeviceVertexAttributeDivisorProperties::supportsNonZeroFirstInstance is VK_FALSE, then firstInstance must be 0", @@ -45310,11 +45752,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndexed-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -45340,16 +45777,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndexed-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -45470,6 +45897,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndexed-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -46480,6 +46917,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndexed-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -46570,6 +47027,11 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-02712", "text": "If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource", @@ -46690,26 +47152,6 @@ "text": "If a shader object is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage or a graphics pipeline is bound which was created with both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage and the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled, then vkCmdSetTessellationDomainOriginEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-08684", - "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-08685", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-08686", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-08687", - "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndexed-None-07312", "text": "If the maintenance6 feature is not enabled, a valid index buffer must be bound", @@ -46939,11 +47381,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMultiEXT-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -46969,16 +47406,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMultiEXT-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -47099,6 +47526,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMultiEXT-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -48109,6 +48546,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMultiEXT-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -48199,6 +48656,11 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-02712", "text": "If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource", @@ -48319,26 +48781,6 @@ "text": "If a shader object is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage or a graphics pipeline is bound which was created with both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage and the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled, then vkCmdSetTessellationDomainOriginEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-08684", - "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-08685", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-08686", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-08687", - "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMultiEXT-pNext-09461", "text": "If the bound graphics pipeline state was created with VkPipelineVertexInputDivisorStateCreateInfo in the pNext chain of VkGraphicsPipelineCreateInfo::pVertexInputState, any member of VkPipelineVertexInputDivisorStateCreateInfo::pVertexBindingDivisors has a value other than 1 in divisor, and VkPhysicalDeviceVertexAttributeDivisorProperties::supportsNonZeroFirstInstance is VK_FALSE, then firstInstance must be 0", @@ -48578,11 +49020,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -48608,16 +49045,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -48738,6 +49165,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -49748,6 +50185,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -49838,6 +50295,11 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-02712", "text": "If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource", @@ -49958,26 +50420,6 @@ "text": "If a shader object is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage or a graphics pipeline is bound which was created with both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage and the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled, then vkCmdSetTessellationDomainOriginEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08684", - "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08685", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08686", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08687", - "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07312", "text": "If the maintenance6 feature is not enabled, a valid index buffer must be bound", @@ -50232,11 +50674,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndirect-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -50262,16 +50699,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndirect-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -50392,6 +50819,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndirect-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -51402,6 +51839,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndirect-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -51492,6 +51949,11 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndirect-None-04007", "text": "All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound", @@ -51597,26 +52059,6 @@ "text": "If a shader object is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage or a graphics pipeline is bound which was created with both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage and the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled, then vkCmdSetTessellationDomainOriginEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-08684", - "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-08685", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-08686", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-08687", - "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndirect-buffer-02708", "text": "If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", @@ -51900,11 +52342,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndirectCount-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -51930,16 +52367,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndirectCount-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -52060,6 +52487,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndirectCount-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -53070,6 +53507,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndirectCount-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -53160,6 +53617,11 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndirectCount-None-04007", "text": "All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound", @@ -53265,26 +53727,6 @@ "text": "If a shader object is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage or a graphics pipeline is bound which was created with both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage and the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled, then vkCmdSetTessellationDomainOriginEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-08684", - "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-08685", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-08686", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-08687", - "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndirectCount-buffer-02708", "text": "If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", @@ -53569,11 +54011,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndexedIndirect-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -53599,16 +54036,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndexedIndirect-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -53729,6 +54156,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndexedIndirect-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -54739,6 +55176,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -54829,6 +55286,11 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04007", "text": "All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound", @@ -54934,26 +55396,6 @@ "text": "If a shader object is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage or a graphics pipeline is bound which was created with both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage and the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled, then vkCmdSetTessellationDomainOriginEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08684", - "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08685", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08686", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08687", - "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndexedIndirect-buffer-02708", "text": "If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", @@ -55247,11 +55689,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -55277,16 +55714,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -55407,6 +55834,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -56417,6 +56854,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -56507,6 +56964,11 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04007", "text": "All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound", @@ -56612,26 +57074,6 @@ "text": "If a shader object is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage or a graphics pipeline is bound which was created with both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage and the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled, then vkCmdSetTessellationDomainOriginEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08684", - "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08685", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08686", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08687", - "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-buffer-02708", "text": "If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", @@ -56921,11 +57363,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -56951,16 +57388,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -57081,6 +57508,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -58091,6 +58528,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -58181,6 +58638,11 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04007", "text": "All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound", @@ -58286,26 +58748,6 @@ "text": "If a shader object is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage or a graphics pipeline is bound which was created with both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage and the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled, then vkCmdSetTessellationDomainOriginEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08684", - "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08685", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08686", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08687", - "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-pNext-09461", "text": "If the bound graphics pipeline state was created with VkPipelineVertexInputDivisorStateCreateInfo in the pNext chain of VkGraphicsPipelineCreateInfo::pVertexInputState, any member of VkPipelineVertexInputDivisorStateCreateInfo::pVertexBindingDivisors has a value other than 1 in divisor, and VkPhysicalDeviceVertexAttributeDivisorProperties::supportsNonZeroFirstInstance is VK_FALSE, then firstInstance must be 0", @@ -58697,11 +59139,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMeshTasksNV-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -58727,16 +59164,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMeshTasksNV-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -58857,6 +59284,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksNV-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -59867,6 +60304,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -59957,11 +60414,21 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksNV-stage-06480", "text": "The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of any element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-pStages-10680", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must not have last bound the pStages element of VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT with a valid shader object other than VK_NULL_HANDLE", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07074", "text": "Transform Feedback Queries must not be active", @@ -60206,11 +60673,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -60236,16 +60698,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -60366,6 +60818,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -61376,6 +61838,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -61466,11 +61948,21 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-stage-06480", "text": "The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of any element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-pStages-10680", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must not have last bound the pStages element of VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT with a valid shader object other than VK_NULL_HANDLE", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07074", "text": "Transform Feedback Queries must not be active", @@ -61774,11 +62266,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -61804,16 +62291,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -61934,6 +62411,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -62944,6 +63431,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -63034,11 +63541,21 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-stage-06480", "text": "The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of any element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-pStages-10680", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must not have last bound the pStages element of VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT with a valid shader object other than VK_NULL_HANDLE", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07074", "text": "Transform Feedback Queries must not be active", @@ -63353,11 +63870,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMeshTasksEXT-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -63383,16 +63895,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMeshTasksEXT-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -63513,6 +64015,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksEXT-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -64523,6 +65035,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -64613,11 +65145,21 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksEXT-stage-06480", "text": "The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of any element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-pStages-10680", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must not have last bound the pStages element of VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT with a valid shader object other than VK_NULL_HANDLE", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07074", "text": "Transform Feedback Queries must not be active", @@ -64897,11 +65439,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -64927,16 +65464,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -65057,6 +65584,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -66067,6 +66604,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -66157,11 +66714,21 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-stage-06480", "text": "The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of any element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-pStages-10680", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must not have last bound the pStages element of VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT with a valid shader object other than VK_NULL_HANDLE", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07074", "text": "Transform Feedback Queries must not be active", @@ -66500,11 +67067,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -66530,16 +67092,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -66660,6 +67212,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -67670,6 +68232,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -67760,11 +68342,21 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-stage-06480", "text": "The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of any element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-pStages-10680", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must not have last bound the pStages element of VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT with a valid shader object other than VK_NULL_HANDLE", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07074", "text": "Transform Feedback Queries must not be active", @@ -68079,11 +68671,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawClusterHUAWEI-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -68109,16 +68696,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawClusterHUAWEI-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -68239,6 +68816,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawClusterHUAWEI-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -69249,6 +69836,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -69339,11 +69946,21 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawClusterHUAWEI-stage-06480", "text": "The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of any element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-pStages-10680", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must not have last bound the pStages element of VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT with a valid shader object other than VK_NULL_HANDLE", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07074", "text": "Transform Feedback Queries must not be active", @@ -69603,11 +70220,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -69633,16 +70245,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/drawing.html" }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/drawing.html" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/drawing.html" - }, { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -69763,6 +70365,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -70773,6 +71385,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/drawing.html" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -70863,11 +71495,21 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-stage-06480", "text": "The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of any element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT", "page": "chapters/drawing.html" }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-pStages-10680", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must not have last bound the pStages element of VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT with a valid shader object other than VK_NULL_HANDLE", + "page": "chapters/drawing.html" + }, { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07074", "text": "Transform Feedback Queries must not be active", @@ -71683,6 +72325,11 @@ "text": "Transform feedback must not be made active in a render pass instance with multiview enabled", "page": "chapters/vertexpostproc.html" }, + { + "vuid": "VUID-vkCmdBeginTransformFeedbackEXT-None-10656", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/vertexpostproc.html" + }, { "vuid": "VUID-vkCmdBeginTransformFeedbackEXT-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -71762,6 +72409,11 @@ "text": "For each buffer handle in the pCounterBuffers array that is not VK_NULL_HANDLE it must have been created with a usage value containing VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT", "page": "chapters/vertexpostproc.html" }, + { + "vuid": "VUID-vkCmdEndTransformFeedbackEXT-None-10657", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/vertexpostproc.html" + }, { "vuid": "VUID-vkCmdEndTransformFeedbackEXT-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -76017,11 +76669,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/dispatch.html" }, - { - "vuid": "VUID-vkCmdDispatch-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/dispatch.html" - }, { "vuid": "VUID-vkCmdDispatch-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -76047,16 +76694,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/dispatch.html" }, - { - "vuid": "VUID-vkCmdDispatch-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/dispatch.html" - }, - { - "vuid": "VUID-vkCmdDispatch-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/dispatch.html" - }, { "vuid": "VUID-vkCmdDispatch-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -76177,6 +76814,41 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/dispatch.html" }, + { + "vuid": "VUID-vkCmdDispatch-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatch-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatch-None-10672", + "text": "If the per-tile execution model is not enabled, this command must be called outside of a render pass instance", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatch-aspectMask-10673", + "text": "If this command is recorded where per-tile execution model is enabled, and if the VkPipeline object bound to the pipeline bind point used by this command writes to a variable of storage class Storage Class TileAttachmentQCOM, the corresponding VkImageView using must not have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatch-None-10674", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDispatch feature must be enabled", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatch-None-10675", + "text": "Memory backing image subresources used as tile attachments in the current render pass must not be written in any way other than as a tile attachment by this command", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatch-None-10676", + "text": "If any recorded command in the current subpass will write to an image subresource as a tile attachment, this command must not read from the memory backing that image subresource in any other way than as a tile attachment", + "page": "chapters/dispatch.html" + }, { "vuid": "VUID-vkCmdDispatch-commandBuffer-02712", "text": "If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource", @@ -76222,11 +76894,6 @@ "text": "The VkCommandPool that commandBuffer was allocated from must support compute operations", "page": "chapters/dispatch.html" }, - { - "vuid": "VUID-vkCmdDispatch-renderpass", - "text": "This command must only be called outside of a render pass instance", - "page": "chapters/dispatch.html" - }, { "vuid": "VUID-vkCmdDispatch-videocoding", "text": "This command must only be called outside of a video coding scope", @@ -76416,11 +77083,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/dispatch.html" }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/dispatch.html" - }, { "vuid": "VUID-vkCmdDispatchIndirect-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -76446,16 +77108,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/dispatch.html" }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/dispatch.html" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/dispatch.html" - }, { "vuid": "VUID-vkCmdDispatchIndirect-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -76576,6 +77228,41 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/dispatch.html" }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-10672", + "text": "If the per-tile execution model is not enabled, this command must be called outside of a render pass instance", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-aspectMask-10673", + "text": "If this command is recorded where per-tile execution model is enabled, and if the VkPipeline object bound to the pipeline bind point used by this command writes to a variable of storage class Storage Class TileAttachmentQCOM, the corresponding VkImageView using must not have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-10674", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDispatch feature must be enabled", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-10675", + "text": "Memory backing image subresources used as tile attachments in the current render pass must not be written in any way other than as a tile attachment by this command", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-10676", + "text": "If any recorded command in the current subpass will write to an image subresource as a tile attachment, this command must not read from the memory backing that image subresource in any other way than as a tile attachment", + "page": "chapters/dispatch.html" + }, { "vuid": "VUID-vkCmdDispatchIndirect-buffer-02708", "text": "If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", @@ -76621,11 +77308,6 @@ "text": "The VkCommandPool that commandBuffer was allocated from must support compute operations", "page": "chapters/dispatch.html" }, - { - "vuid": "VUID-vkCmdDispatchIndirect-renderpass", - "text": "This command must only be called outside of a render pass instance", - "page": "chapters/dispatch.html" - }, { "vuid": "VUID-vkCmdDispatchIndirect-videocoding", "text": "This command must only be called outside of a video coding scope", @@ -76839,11 +77521,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/dispatch.html" }, - { - "vuid": "VUID-vkCmdDispatchBase-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/dispatch.html" - }, { "vuid": "VUID-vkCmdDispatchBase-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -76869,16 +77546,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/dispatch.html" }, - { - "vuid": "VUID-vkCmdDispatchBase-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/dispatch.html" - }, - { - "vuid": "VUID-vkCmdDispatchBase-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/dispatch.html" - }, { "vuid": "VUID-vkCmdDispatchBase-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -76999,6 +77666,41 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/dispatch.html" }, + { + "vuid": "VUID-vkCmdDispatchBase-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-10672", + "text": "If the per-tile execution model is not enabled, this command must be called outside of a render pass instance", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchBase-aspectMask-10673", + "text": "If this command is recorded where per-tile execution model is enabled, and if the VkPipeline object bound to the pipeline bind point used by this command writes to a variable of storage class Storage Class TileAttachmentQCOM, the corresponding VkImageView using must not have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-10674", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDispatch feature must be enabled", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-10675", + "text": "Memory backing image subresources used as tile attachments in the current render pass must not be written in any way other than as a tile attachment by this command", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-10676", + "text": "If any recorded command in the current subpass will write to an image subresource as a tile attachment, this command must not read from the memory backing that image subresource in any other way than as a tile attachment", + "page": "chapters/dispatch.html" + }, { "vuid": "VUID-vkCmdDispatchBase-commandBuffer-02712", "text": "If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource", @@ -77065,17 +77767,440 @@ "page": "chapters/dispatch.html" }, { - "vuid": "VUID-vkCmdDispatchBase-renderpass", - "text": "This command must only be called outside of a render pass instance", + "vuid": "VUID-vkCmdDispatchBase-videocoding", + "text": "This command must only be called outside of a video coding scope", + "page": "chapters/dispatch.html" + } + ] + }, + "vkCmdDispatchTileQCOM": { + "core": [ + { + "vuid": "VUID-vkCmdDispatchTileQCOM-magFilter-04553", + "text": "If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR, reductionMode equal to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT", "page": "chapters/dispatch.html" }, { - "vuid": "VUID-vkCmdDispatchBase-videocoding", + "vuid": "VUID-vkCmdDispatchTileQCOM-magFilter-09598", + "text": "If a VkSampler created with magFilter or minFilter equal to VK_FILTER_LINEAR and reductionMode equal to either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-mipmapMode-04770", + "text": "If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR, reductionMode equal to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-mipmapMode-09599", + "text": "If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and reductionMode equal to either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-unnormalizedCoordinates-09635", + "text": "If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view’s levelCount and layerCount must be 1", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08609", + "text": "If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view’s viewType must be VK_IMAGE_VIEW_TYPE_1D or VK_IMAGE_VIEW_TYPE_2D", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08610", + "text": "If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08611", + "text": "If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-06479", + "text": "If a VkImageView is sampled with depth comparison, the image view’s format features must contain VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-02691", + "text": "If a VkImageView is accessed using atomic operations as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-07888", + "text": "If a VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER descriptor is accessed using atomic operations as a result of this command, then the storage texel buffer’s format features must contain VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-02692", + "text": "If a VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-02693", + "text": "If the VK_EXT_filter_cubic extension is not enabled and any VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, it must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-filterCubic-02694", + "text": "Any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have a VkImageViewType and format that supports cubic filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubic returned by vkGetPhysicalDeviceImageFormatProperties2", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-filterCubicMinmax-02695", + "text": "Any VkImageView being sampled with VK_FILTER_CUBIC_EXT with a reduction mode of either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX as a result of this command must have a VkImageViewType and format that supports cubic filtering together with minmax filtering, as specified by VkFilterCubicImageViewImageFormatPropertiesEXT::filterCubicMinmax returned by vkGetPhysicalDeviceImageFormatProperties2", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-cubicRangeClamp-09212", + "text": "If the cubicRangeClamp feature is not enabled, then any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must not have a VkSamplerReductionModeCreateInfo::reductionMode equal to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-reductionMode-09213", + "text": "Any VkImageView being sampled with a VkSamplerReductionModeCreateInfo::reductionMode equal to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM as a result of this command must sample with VK_FILTER_CUBIC_EXT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-selectableCubicWeights-09214", + "text": "If the selectableCubicWeights feature is not enabled, then any VkImageView being sampled with VK_FILTER_CUBIC_EXT as a result of this command must have VkSamplerCubicWeightsCreateInfoQCOM::cubicWeights equal to VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-flags-02696", + "text": "Any VkImage created with a VkImageCreateInfo::flags containing VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV sampled as a result of this command must only be sampled using a VkSamplerAddressMode of VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpTypeImage-07027", + "text": "For any VkImageView being written as a storage image where the image format field of the OpTypeImage is Unknown, the view’s format features must contain VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpTypeImage-07028", + "text": "For any VkImageView being read as a storage image where the image format field of the OpTypeImage is Unknown, the view’s format features must contain VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpTypeImage-07029", + "text": "For any VkBufferView being written as a storage texel buffer where the image format field of the OpTypeImage is Unknown, the view’s buffer features must contain VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpTypeImage-07030", + "text": "Any VkBufferView being read as a storage texel buffer where the image format field of the OpTypeImage is Unknown then the view’s buffer features must contain VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08600", + "text": "For each set n that is statically used by a bound shader, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline or the VkDescriptorSetLayout array used to create the current VkShaderEXT , as described in Pipeline Layout Compatibility", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08601", + "text": "For each push constant that is statically used by a bound shader, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline or the VkDescriptorSetLayout array used to create the current VkShaderEXT , as described in Pipeline Layout Compatibility", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-10068", + "text": "For each array of resources that is used by a bound shader, the indices used to access members of the array must be less than the descriptor count for the identified binding in the descriptor sets used by this command", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-maintenance4-08602", + "text": "If the maintenance4 feature is not enabled, then for each push constant that is statically used by a bound shader, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline or the VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkShaderEXT , as described in Pipeline Layout Compatibility", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08114", + "text": "Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by the VkPipeline bound to the pipeline bind point used by this command and the bound VkPipeline was not created with VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08115", + "text": "If the descriptors used by the VkPipeline bound to the pipeline bind point were specified via vkCmdBindDescriptorSets, the bound VkPipeline must have been created without VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08116", + "text": "Descriptors in bound descriptor buffers, specified via vkCmdSetDescriptorBufferOffsetsEXT, must be valid if they are dynamically used by the VkPipeline bound to the pipeline bind point used by this command and the bound VkPipeline was created with VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08604", + "text": "Descriptors in bound descriptor buffers, specified via vkCmdSetDescriptorBufferOffsetsEXT, must be valid if they are dynamically used by any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08117", + "text": "If the descriptors used by the VkPipeline bound to the pipeline bind point were specified via vkCmdSetDescriptorBufferOffsetsEXT, the bound VkPipeline must have been created with VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08119", + "text": "If a descriptor is dynamically used with a VkPipeline created with VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, the descriptor memory must be resident", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08605", + "text": "If a descriptor is dynamically used with a VkShaderEXT created with a VkDescriptorSetLayout that was created with VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT, the descriptor memory must be resident", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08606", + "text": "If the shaderObject feature is not enabled, a valid pipeline must be bound to the pipeline bind point used by this command", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08608", + "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-uniformBuffers-06935", + "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08612", + "text": "If the robustBufferAccess feature is not enabled, and any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a uniform buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-storageBuffers-06936", + "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for storageBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-08613", + "text": "If the robustBufferAccess feature is not enabled, and any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a storage buffer, it must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-commandBuffer-02707", + "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-viewType-07752", + "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-format-07753", + "text": "If a VkImageView or VkBufferView is accessed as a result of this command, then the numeric type of the view’s format and the Sampled Type operand of the OpTypeImage must match", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageWrite-08795", + "text": "If a VkImageView created with a format other than VK_FORMAT_A8_UNORM is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view’s format", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageWrite-08796", + "text": "If a VkImageView created with the format VK_FORMAT_A8_UNORM is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have four components", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageWrite-04469", + "text": "If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view’s format", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-SampledType-04470", + "text": "If a VkImageView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-SampledType-04471", + "text": "If a VkImageView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-SampledType-04472", + "text": "If a VkBufferView with a VkFormat that has a 64-bit component width is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 64", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-SampledType-04473", + "text": "If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-sparseImageInt64Atomics-04474", + "text": "If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-sparseImageInt64Atomics-04475", + "text": "If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageWeightedSampleQCOM-06971", + "text": "If OpImageWeightedSampleQCOM is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageWeightedSampleQCOM-06972", + "text": "If OpImageWeightedSampleQCOM uses a VkImageView as a sample weight image as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageBoxFilterQCOM-06973", + "text": "If OpImageBoxFilterQCOM is used to sample a VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageBlockMatchSSDQCOM-06974", + "text": "If OpImageBlockMatchSSDQCOM is used to read from an VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageBlockMatchSADQCOM-06975", + "text": "If OpImageBlockMatchSADQCOM is used to read from an VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageBlockMatchSADQCOM-06976", + "text": "If OpImageBlockMatchSADQCOM or OpImageBlockMatchSSDQCOM is used to read from a reference image as result of this command, then the specified reference coordinates must not fail integer texel coordinate validation", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageWeightedSampleQCOM-06977", + "text": "If OpImageWeightedSampleQCOM, OpImageBoxFilterQCOM, OpImageBlockMatchWindowSSDQCOM, OpImageBlockMatchWindowSADQCOM, OpImageBlockMatchGatherSSDQCOM, OpImageBlockMatchGatherSADQCOM, OpImageBlockMatchSSDQCOM, or OpImageBlockMatchSADQCOM uses a VkSampler as a result of this command, then the sampler must have been created with VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageWeightedSampleQCOM-06978", + "text": "If any command other than OpImageWeightedSampleQCOM, OpImageBoxFilterQCOM, OpImageBlockMatchWindowSSDQCOM, OpImageBlockMatchWindowSADQCOM, OpImageBlockMatchGatherSSDQCOM, OpImageBlockMatchGatherSADQCOM, OpImageBlockMatchSSDQCOM, or OpImageBlockMatchSADQCOM uses a VkSampler as a result of this command, then the sampler must not have been created with VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageBlockMatchWindow-09215", + "text": "If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM instruction is used to read from an VkImageView as a result of this command, then the image view’s format features must contain VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageBlockMatchWindow-09216", + "text": "If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM instruction is used to read from an VkImageView as a result of this command, then the image view’s format must be a single-component format", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-OpImageBlockMatchWindow-09217", + "text": "If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM read from a reference image as result of this command, then the specified reference coordinates must not fail integer texel coordinate validation", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-07288", + "text": "Any shader invocation executed by this command must terminate", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-09600", + "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-10672", + "text": "If the per-tile execution model is not enabled, this command must be called outside of a render pass instance", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-aspectMask-10673", + "text": "If this command is recorded where per-tile execution model is enabled, and if the VkPipeline object bound to the pipeline bind point used by this command writes to a variable of storage class Storage Class TileAttachmentQCOM, the corresponding VkImageView using must not have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-10674", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDispatch feature must be enabled", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-10675", + "text": "Memory backing image subresources used as tile attachments in the current render pass must not be written in any way other than as a tile attachment by this command", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-10676", + "text": "If any recorded command in the current subpass will write to an image subresource as a tile attachment, this command must not read from the memory backing that image subresource in any other way than as a tile attachment", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-commandBuffer-02712", + "text": "If commandBuffer is a protected command buffer and protectedNoFault is not supported, any resource written to by the VkPipeline object bound to the pipeline bind point used by this command must not be an unprotected resource", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-commandBuffer-02713", + "text": "If commandBuffer is a protected command buffer and protectedNoFault is not supported, pipeline stages other than the framebuffer-space and compute stages in the VkPipeline object bound to the pipeline bind point used by this command must not write to any resource", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-commandBuffer-04617", + "text": "If any of the shader stages of the VkPipeline bound to the pipeline bind point used by this command uses the RayQueryKHR capability, then commandBuffer must not be a protected command buffer", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-10668", + "text": "When this command is recorded per-tile execution model must be enabled", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-None-10669", + "text": "The tileShadingDispatchTile must enabled", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-commandBuffer-parameter", + "text": "commandBuffer must be a valid VkCommandBuffer handle", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-commandBuffer-recording", + "text": "commandBuffer must be in the recording state", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-commandBuffer-cmdpool", + "text": "The VkCommandPool that commandBuffer was allocated from must support compute operations", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-renderpass", + "text": "This command must only be called inside of a render pass instance", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdDispatchTileQCOM-videocoding", "text": "This command must only be called outside of a video coding scope", "page": "chapters/dispatch.html" } ] }, + "VkDispatchTileInfoQCOM": { + "core": [ + { + "vuid": "VUID-VkDispatchTileInfoQCOM-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-VkDispatchTileInfoQCOM-pNext-pNext", + "text": "pNext must be NULL", + "page": "chapters/dispatch.html" + } + ] + }, "vkCmdSubpassShadingHUAWEI": { "core": [ { @@ -77258,11 +78383,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/dispatch.html" }, - { - "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/dispatch.html" - }, { "vuid": "VUID-vkCmdSubpassShadingHUAWEI-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -77288,16 +78408,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/dispatch.html" }, - { - "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/dispatch.html" - }, - { - "vuid": "VUID-vkCmdSubpassShadingHUAWEI-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/dispatch.html" - }, { "vuid": "VUID-vkCmdSubpassShadingHUAWEI-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -77418,6 +78528,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/dispatch.html" }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/dispatch.html" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/dispatch.html" + }, { "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-04931", "text": "This command must be called in a subpass with bind point VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI. No draw commands can be called in the same subpass. Only one vkCmdSubpassShadingHUAWEI command can be called in a subpass", @@ -79251,11 +80371,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/device_generated_commands/generatedcommands.html" }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/device_generated_commands/generatedcommands.html" - }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -79281,16 +80396,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/device_generated_commands/generatedcommands.html" }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/device_generated_commands/generatedcommands.html" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/device_generated_commands/generatedcommands.html" - }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -79411,6 +80516,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/device_generated_commands/generatedcommands.html" }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -80421,6 +81536,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/device_generated_commands/generatedcommands.html" }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -80511,6 +81646,11 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/device_generated_commands/generatedcommands.html" }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04007", "text": "All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point’s interface must have either valid or VK_NULL_HANDLE buffers bound", @@ -80616,26 +81756,6 @@ "text": "If a shader object is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage or a graphics pipeline is bound which was created with both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stage and the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled, then vkCmdSetTessellationDomainOriginEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", "page": "chapters/device_generated_commands/generatedcommands.html" }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08684", - "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", - "page": "chapters/device_generated_commands/generatedcommands.html" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08685", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", - "page": "chapters/device_generated_commands/generatedcommands.html" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08686", - "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", - "page": "chapters/device_generated_commands/generatedcommands.html" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08687", - "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", - "page": "chapters/device_generated_commands/generatedcommands.html" - }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-02970", "text": "commandBuffer must not be a protected command buffer", @@ -81103,11 +82223,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/device_generated_commands/generatedcommands.html" }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/device_generated_commands/generatedcommands.html" - }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -81133,16 +82248,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/device_generated_commands/generatedcommands.html" }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/device_generated_commands/generatedcommands.html" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/device_generated_commands/generatedcommands.html" - }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -81263,6 +82368,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/device_generated_commands/generatedcommands.html" }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-renderPass-02684", "text": "The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", @@ -82273,6 +83388,26 @@ "text": "If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command", "page": "chapters/device_generated_commands/generatedcommands.html" }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-None-08684", + "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-None-08685", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-None-08686", + "text": "If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-None-08687", + "text": "If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-None-08688", "text": "If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called in the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT", @@ -82363,6 +83498,11 @@ "text": "If the bound graphics pipeline was created with VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT, the current render pass must have begun with vkCmdBeginRendering with the VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT flag", "page": "chapters/device_generated_commands/generatedcommands.html" }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-None-10677", + "text": "If the per-tile execution model is enabled, the tileShadingPerTileDraw feature must be enabled", + "page": "chapters/device_generated_commands/generatedcommands.html" + }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsEXT-commandBuffer-11045", "text": "commandBuffer must not be a protected command buffer", @@ -92293,11 +93433,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/raytracing.html" }, - { - "vuid": "VUID-vkCmdTraceRaysNV-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/raytracing.html" - }, { "vuid": "VUID-vkCmdTraceRaysNV-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -92323,16 +93458,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/raytracing.html" }, - { - "vuid": "VUID-vkCmdTraceRaysNV-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/raytracing.html" - }, - { - "vuid": "VUID-vkCmdTraceRaysNV-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/raytracing.html" - }, { "vuid": "VUID-vkCmdTraceRaysNV-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -92453,6 +93578,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/raytracing.html" }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/raytracing.html" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/raytracing.html" + }, { "vuid": "VUID-vkCmdTraceRaysNV-None-03429", "text": "Any shader group handle referenced by this call must have been queried from the bound ray tracing pipeline", @@ -92817,11 +93952,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/raytracing.html" }, - { - "vuid": "VUID-vkCmdTraceRaysKHR-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/raytracing.html" - }, { "vuid": "VUID-vkCmdTraceRaysKHR-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -92847,16 +93977,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/raytracing.html" }, - { - "vuid": "VUID-vkCmdTraceRaysKHR-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/raytracing.html" - }, - { - "vuid": "VUID-vkCmdTraceRaysKHR-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/raytracing.html" - }, { "vuid": "VUID-vkCmdTraceRaysKHR-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -92977,6 +94097,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/raytracing.html" }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/raytracing.html" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/raytracing.html" + }, { "vuid": "VUID-vkCmdTraceRaysKHR-None-03429", "text": "Any shader group handle referenced by this call must have been queried from the bound ray tracing pipeline", @@ -93470,11 +94600,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/raytracing.html" }, - { - "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/raytracing.html" - }, { "vuid": "VUID-vkCmdTraceRaysIndirectKHR-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -93500,16 +94625,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/raytracing.html" }, - { - "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/raytracing.html" - }, - { - "vuid": "VUID-vkCmdTraceRaysIndirectKHR-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/raytracing.html" - }, { "vuid": "VUID-vkCmdTraceRaysIndirectKHR-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -93630,6 +94745,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/raytracing.html" }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/raytracing.html" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/raytracing.html" + }, { "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-03429", "text": "Any shader group handle referenced by this call must have been queried from the bound ray tracing pipeline", @@ -94068,11 +95193,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/raytracing.html" }, - { - "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/raytracing.html" - }, { "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -94098,16 +95218,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/raytracing.html" }, - { - "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/raytracing.html" - }, - { - "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/raytracing.html" - }, { "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -94228,6 +95338,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/raytracing.html" }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/raytracing.html" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/raytracing.html" + }, { "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-03429", "text": "Any shader group handle referenced by this call must have been queried from the bound ray tracing pipeline", @@ -99954,11 +101074,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/executiongraphs.html" }, - { - "vuid": "VUID-vkCmdDispatchGraphAMDX-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/executiongraphs.html" - }, { "vuid": "VUID-vkCmdDispatchGraphAMDX-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -99984,16 +101099,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/executiongraphs.html" }, - { - "vuid": "VUID-vkCmdDispatchGraphAMDX-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/executiongraphs.html" - }, - { - "vuid": "VUID-vkCmdDispatchGraphAMDX-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/executiongraphs.html" - }, { "vuid": "VUID-vkCmdDispatchGraphAMDX-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -100114,6 +101219,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/executiongraphs.html" }, + { + "vuid": "VUID-vkCmdDispatchGraphAMDX-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/executiongraphs.html" + }, + { + "vuid": "VUID-vkCmdDispatchGraphAMDX-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/executiongraphs.html" + }, { "vuid": "VUID-vkCmdDispatchGraphAMDX-commandBuffer-09181", "text": "commandBuffer must not be a protected command buffer", @@ -100403,11 +101518,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/executiongraphs.html" }, - { - "vuid": "VUID-vkCmdDispatchGraphIndirectAMDX-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/executiongraphs.html" - }, { "vuid": "VUID-vkCmdDispatchGraphIndirectAMDX-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -100433,16 +101543,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/executiongraphs.html" }, - { - "vuid": "VUID-vkCmdDispatchGraphIndirectAMDX-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/executiongraphs.html" - }, - { - "vuid": "VUID-vkCmdDispatchGraphIndirectAMDX-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/executiongraphs.html" - }, { "vuid": "VUID-vkCmdDispatchGraphIndirectAMDX-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -100563,6 +101663,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/executiongraphs.html" }, + { + "vuid": "VUID-vkCmdDispatchGraphIndirectAMDX-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/executiongraphs.html" + }, + { + "vuid": "VUID-vkCmdDispatchGraphIndirectAMDX-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/executiongraphs.html" + }, { "vuid": "VUID-vkCmdDispatchGraphIndirectAMDX-commandBuffer-09181", "text": "commandBuffer must not be a protected command buffer", @@ -100872,11 +101982,6 @@ "text": "If a pipeline is bound to the pipeline bind point used by this command, there must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", "page": "chapters/executiongraphs.html" }, - { - "vuid": "VUID-vkCmdDispatchGraphIndirectCountAMDX-None-08607", - "text": "If the shaderObject feature is enabled, either a valid pipeline must be bound to the pipeline bind point used by this command, or a valid combination of valid and VK_NULL_HANDLE shader objects must be bound to every supported shader stage corresponding to the pipeline bind point used by this command", - "page": "chapters/executiongraphs.html" - }, { "vuid": "VUID-vkCmdDispatchGraphIndirectCountAMDX-uniformBuffers-06935", "text": "If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, and that stage was created without enabling either VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2 for uniformBuffers, and the robustBufferAccess feature is not enabled, that stage must not access values outside of the range of the buffer as specified in the descriptor set bound to the same pipeline bind point", @@ -100902,16 +102007,6 @@ "text": "If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", "page": "chapters/executiongraphs.html" }, - { - "vuid": "VUID-vkCmdDispatchGraphIndirectCountAMDX-None-06550", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions", - "page": "chapters/executiongraphs.html" - }, - { - "vuid": "VUID-vkCmdDispatchGraphIndirectCountAMDX-ConstOffset-06551", - "text": "If a bound shader accesses a VkSampler or VkImageView object that enables sampler Y′CBCR conversion, that object must not use the ConstOffset and Offset operands", - "page": "chapters/executiongraphs.html" - }, { "vuid": "VUID-vkCmdDispatchGraphIndirectCountAMDX-viewType-07752", "text": "If a VkImageView is accessed as a result of this command, then the image view’s viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", @@ -101032,6 +102127,16 @@ "text": "If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", "page": "chapters/executiongraphs.html" }, + { + "vuid": "VUID-vkCmdDispatchGraphIndirectCountAMDX-None-10678", + "text": "If this command is recorded inside a tile shading render pass instance, the stages corresponding to the pipeline bind point used by this command must only include VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_FRAGMENT_BIT, and/or VK_SHADER_STAGE_COMPUTE_BIT", + "page": "chapters/executiongraphs.html" + }, + { + "vuid": "VUID-vkCmdDispatchGraphIndirectCountAMDX-None-10679", + "text": "If this command is recorded where per-tile execution model is enabled, there must be no access to any image while the image was be transitioned to the VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT layout", + "page": "chapters/executiongraphs.html" + }, { "vuid": "VUID-vkCmdDispatchGraphIndirectCountAMDX-commandBuffer-09181", "text": "commandBuffer must not be a protected command buffer", @@ -101178,6 +102283,129 @@ } ] }, + "vkCreateExternalComputeQueueNV": { + "core": [ + { + "vuid": "VUID-vkCreateExternalComputeQueueNV-device-parameter", + "text": "device must be a valid VkDevice handle", + "page": "vkspec" + }, + { + "vuid": "VUID-vkCreateExternalComputeQueueNV-pCreateInfo-parameter", + "text": "pCreateInfo must be a valid pointer to a valid VkExternalComputeQueueCreateInfoNV structure", + "page": "vkspec" + }, + { + "vuid": "VUID-vkCreateExternalComputeQueueNV-pAllocator-parameter", + "text": "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", + "page": "vkspec" + }, + { + "vuid": "VUID-vkCreateExternalComputeQueueNV-pExternalQueue-parameter", + "text": "pExternalQueue must be a valid pointer to a VkExternalComputeQueueNV handle", + "page": "vkspec" + } + ] + }, + "vkDestroyExternalComputeQueueNV": { + "core": [ + { + "vuid": "VUID-vkDestroyExternalComputeQueueNV-device-parameter", + "text": "device must be a valid VkDevice handle", + "page": "vkspec" + }, + { + "vuid": "VUID-vkDestroyExternalComputeQueueNV-externalQueue-parameter", + "text": "externalQueue must be a valid VkExternalComputeQueueNV handle", + "page": "vkspec" + }, + { + "vuid": "VUID-vkDestroyExternalComputeQueueNV-pAllocator-parameter", + "text": "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure", + "page": "vkspec" + }, + { + "vuid": "VUID-vkDestroyExternalComputeQueueNV-externalQueue-parent", + "text": "externalQueue must have been created, allocated, or retrieved from device", + "page": "vkspec" + } + ] + }, + "vkGetExternalComputeQueueDataNV": { + "core": [ + { + "vuid": "VUID-vkGetExternalComputeQueueDataNV-pData-08134", + "text": "pData must be at least the size specified by the externalDataSize field in the VkPhysicalDeviceExternalComputeQueuePropertiesNV structure.", + "page": "vkspec" + }, + { + "vuid": "VUID-vkGetExternalComputeQueueDataNV-externalQueue-parameter", + "text": "externalQueue must be a valid VkExternalComputeQueueNV handle", + "page": "vkspec" + }, + { + "vuid": "VUID-vkGetExternalComputeQueueDataNV-params-parameter", + "text": "params must be a valid pointer to a VkExternalComputeQueueDataParamsNV structure", + "page": "vkspec" + }, + { + "vuid": "VUID-vkGetExternalComputeQueueDataNV-pData-parameter", + "text": "pData must be a pointer value", + "page": "vkspec" + } + ] + }, + "VkExternalComputeQueueDeviceCreateInfoNV": { + "core": [ + { + "vuid": "VUID-VkExternalComputeQueueDeviceCreateInfoNV-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV", + "page": "vkspec" + } + ] + }, + "VkExternalComputeQueueCreateInfoNV": { + "core": [ + { + "vuid": "VUID-VkExternalComputeQueueCreateInfoNV-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV", + "page": "vkspec" + }, + { + "vuid": "VUID-VkExternalComputeQueueCreateInfoNV-pNext-pNext", + "text": "pNext must be NULL", + "page": "vkspec" + }, + { + "vuid": "VUID-VkExternalComputeQueueCreateInfoNV-preferredQueue-parameter", + "text": "preferredQueue must be a valid VkQueue handle", + "page": "vkspec" + } + ] + }, + "VkExternalComputeQueueDataParamsNV": { + "core": [ + { + "vuid": "VUID-VkExternalComputeQueueDataParamsNV-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV", + "page": "vkspec" + }, + { + "vuid": "VUID-VkExternalComputeQueueDataParamsNV-pNext-pNext", + "text": "pNext must be NULL", + "page": "vkspec" + } + ] + }, + "VkPhysicalDeviceExternalComputeQueuePropertiesNV": { + "core": [ + { + "vuid": "VUID-VkPhysicalDeviceExternalComputeQueuePropertiesNV-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV", + "page": "vkspec" + } + ] + }, "vkEnumerateInstanceLayerProperties": { "core": [ { @@ -103072,6 +104300,15 @@ } ] }, + "VkPhysicalDeviceTileShadingFeaturesQCOM": { + "core": [ + { + "vuid": "VUID-VkPhysicalDeviceTileShadingFeaturesQCOM-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM", + "page": "chapters/features.html" + } + ] + }, "VkPhysicalDeviceSchedulingControlsFeaturesARM": { "core": [ { @@ -104065,6 +105302,15 @@ } ] }, + "VkPhysicalDeviceTileShadingPropertiesQCOM": { + "core": [ + { + "vuid": "VUID-VkPhysicalDeviceTileShadingPropertiesQCOM-sType-sType", + "text": "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM", + "page": "chapters/limits.html" + } + ] + }, "vkGetPhysicalDeviceMultisamplePropertiesEXT": { "core": [ { @@ -105327,6 +106573,11 @@ }, "vkCmdDebugMarkerBeginEXT": { "core": [ + { + "vuid": "VUID-vkCmdDebugMarkerBeginEXT-None-10614", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/debugging.html" + }, { "vuid": "VUID-vkCmdDebugMarkerBeginEXT-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -105385,6 +106636,11 @@ "text": "If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdDebugMarkerBeginEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdDebugMarkerEndEXT", "page": "chapters/debugging.html" }, + { + "vuid": "VUID-vkCmdDebugMarkerEndEXT-None-10615", + "text": "This command must not be recorded when per-tile execution model is enabled", + "page": "chapters/debugging.html" + }, { "vuid": "VUID-vkCmdDebugMarkerEndEXT-commandBuffer-parameter", "text": "commandBuffer must be a valid VkCommandBuffer handle", @@ -106156,6 +107412,11 @@ "text": "The pointers of any Input or Output Interface user-defined variables must not contain any PhysicalStorageBuffer Storage Class pointers", "page": "appendices/spirvenv.html" }, + { + "vuid": "VUID-StandaloneSpirv-None-10684", + "text": "All variables must have valid explicit layout decorations as described in Shader Interfaces", + "page": "appendices/spirvenv.html" + }, { "vuid": "VUID-StandaloneSpirv-GLSLShared-04669", "text": "The GLSLShared and GLSLPacked decorations must not be used", @@ -106237,8 +107498,8 @@ "page": "appendices/spirvenv.html" }, { - "vuid": "VUID-StandaloneSpirv-LocalSize-06426", - "text": "For each compute shader entry point, either a LocalSize or LocalSizeId Execution Mode, or an object decorated with the WorkgroupSize decoration must be specified", + "vuid": "VUID-StandaloneSpirv-None-10685", + "text": "For each compute shader entry point, either a TileShadingRateQCOM, LocalSize, or LocalSizeId Execution Mode, or an object decorated with the WorkgroupSize decoration must be specified", "page": "appendices/spirvenv.html" }, { @@ -106573,7 +107834,67 @@ }, { "vuid": "VUID-StandaloneSpirv-StorageTexelBufferArrayDynamicIndexing-10133", - "text": "If the StorageTexelBufferArrayDynamicIndexing capability is not declared, and an instruction accesses memory through a storage texel buffer, the storage texel buffer through which that memory is accessed must be determined by constant integral expressions", + "text": "If the StorageTexelBufferArrayDynamicIndexing capability is not declared, and an instruction accesses memory through a storage texel buffer, the storage texel buffer through which that memory is accessed must be determined by constant integral expressions PhysicalStorageBuffer.", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-StandaloneSpirv-TileShadingQCOM-10686", + "text": "TileShadingQCOM capability must not be enabled in any stage other than compute or fragment", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-StandaloneSpirv-Execution-10687", + "text": "Execution Mode NonCoherentTileAttachmentReadQCOM must not be used in any stage other than fragment", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-StandaloneSpirv-Execution-10688", + "text": "Execution Mode TileShadingRateQCOM must not be used in any stage other than compute", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-StandaloneSpirv-TileAttachmentQCOM-10689", + "text": "If the TileAttachmentQCOM Storage Class is used, the TileShadingQCOM capability must be enabled", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-StandaloneSpirv-NonCoherentTileAttachmentReadQCOM-10690", + "text": "If the NonCoherentTileAttachmentReadQCOM Execution Mode is used, the TileShadingQCOM capability must be enabled", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-StandaloneSpirv-TileShadingRateQCOM-10691", + "text": "If the TileShadingRateQCOM Execution Mode is used, the TileShadingQCOM capability must be enabled", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-StandaloneSpirv-TileShadingRateQCOM-10692", + "text": "If the TileShadingRateQCOM Execution Mode is used, LocalSize and LocalSizeId Execution Mode must not be specified", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-StandaloneSpirv-OpTypeImage-10693", + "text": "OpTypeImage variables in the TileAttachmentQCOM Storage Class must have Dim equal to 2D", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-StandaloneSpirv-OpTypeImage-10694", + "text": "OpTypeImage variables in the TileAttachmentQCOM Storage Class must Sampled equal to 1 or 2", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-StandaloneSpirv-TileAttachmentQCOM-10695", + "text": "Any variable in the TileAttachmentQCOM Storage Class must be decorated with DescriptorSet and Binding", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-StandaloneSpirv-TileAttachmentQCOM-10696", + "text": "Any variable in the TileAttachmentQCOM Storage Class must not be decorated with Component decoration", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-StandaloneSpirv-TileAttachmentQCOM-10697", + "text": "An OpTypeImage variables in the TileAttachmentQCOM Storage Class must not be consumed by an OpImageQuery* instruction", "page": "appendices/spirvenv.html" } ] @@ -107834,6 +109155,111 @@ "vuid": "VUID-RuntimeSpirv-meshAndTaskShaderDerivatives-10153", "text": "If meshAndTaskShaderDerivatives is VK_FALSE, the DerivativeGroupLinearKHR and DerivativeGroupQuadsKHR execution modes must not be used in the MeshEXT, MeshNV, TaskEXT, or TaskNV Execution Model", "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-TileShadingQCOM-10698", + "text": "TileShadingQCOM capability must not be declared in the compute stage unless the tileShading feature is enabled", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-TileShadingQCOM-10699", + "text": "The TileShadingQCOM capability must not be declared in the fragment stage unless the tileShadingFragmentStage feature is enabled", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-TileShadingQCOM-10700", + "text": "A shader that enables SPIR-V capability TileShadingQCOM must not be invoked outside a tile shading render pass", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-TileShadingQCOM-10701", + "text": "A compute shader that enables SPIR-V capability TileShadingQCOM must only be invoked inside those portions of a command buffer where per-tile execution model is enabled", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-x-10702", + "text": "In compute shaders that enables SPIR-V capability TileShadingQCOM, the x size in TileShadingRateQCOM must be less than or equal to VkPhysicalDeviceTileShadingPropertiesQCOM::maxTileShadingRate::x", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-y-10703", + "text": "In compute shaders that enables SPIR-V capability TileShadingQCOM, the y size in TileShadingRateQCOM must be less than or equal to VkPhysicalDeviceTileShadingPropertiesQCOM::maxTileShadingRate::y", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-z-10704", + "text": "In compute shaders that enables SPIR-V capability TileShadingQCOM, the z size in TileShadingRateQCOM must be less than or equal to VkTilePropertiesQCOM::tileSize::z", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-tileSize-10705", + "text": "In compute shaders that enables SPIR-V capability TileShadingQCOM, VkTilePropertiesQCOM::tileSize::z % TileShadingRateQCOM::z must equal 0", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-OpImage-10706", + "text": "An OpImage with Storage Class TileAttachmentQCOM must not be consumed by OpImageTexelPointer unless the tileShadingAtomicOps feature is enabled", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-OpTypeImage-10707", + "text": "An OpTypeImage with Storage Class TileAttachmentQCOM must not be backed by a view equivalent to the color attachment of the current subpass instance unless the tileShadingColorAttachments feature is enabled", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-OpTypeImage-10708", + "text": "An OpTypeImage with Storage Class TileAttachmentQCOM must not be backed by a view equivalent to the depth aspect of the depth/stencil attachment of the current subpass instance unless the tileShadingDepthAttachments", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-OpTypeImage-10709", + "text": "An OpTypeImage with Storage Class TileAttachmentQCOM must not be backed by a view equivalent to the stencil aspect of the depth/stencil attachment of the current subpass instance unless the tileShadingStencilAttachments feature is enabled", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-OpTypeImage-10710", + "text": "An OpTypeImage with Storage Class TileAttachmentQCOM must not be backed by a view equivalent to the input attachment of the current subpass instance unless the tileShadingInputAttachments feature is enabled", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-OpTypeSampledImage-10711", + "text": "An OpTypeSampledImage with Storage Class TileAttachmentQCOM must not be backed by a view equivalent to an attachment of the current subpass instance unless the tileShadingSampledAttachments feature is enabled", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-tileShadingImageProcessing-10712", + "text": "If an OpTypeSampledImage with Storage Class TileAttachmentQCOM is consumed by any argument of the following operations, tileShadingImageProcessing must be enabled:
\n
    \n
  • \n

    OpImageSampleWeightedQCOM

    \n
    • \n
  • \n

    OpImageBoxFilterQCOM

    \n
    • \n
  • \n

    OpImageBlockMatch*QCOM

    \n
    • \n
\n
", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-Coordinate-10713", + "text": "The Coordinate operand of any OpImageRead, OpImageSparseRead, OpImageWrite, or OpImageTexelPointer instruction that consumes an OpTypeImage with an image Storage Class TileAttachmentQCOM must not result in any texels accessed outside the boundaries of the current tile, computed as described in Tile Attachments", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-Coordinate-10714", + "text": "The Coordinate operand(s) of any of the following instructions that consumes an OpTypeSampledImage with an image of Storage Class TileAttachmentQCOM must not result in any texels accessed outside boundaries of the current tile, computed as described in Tile Attachments:
\n
    \n
  • \n

    OpImageSample*

    \n
    • \n
  • \n

    OpImageSparseSample*

    \n
    • \n
  • \n

    OpImageFetch

    \n
    • \n
  • \n

    OpImageSparseFetch

    \n
    • \n
  • \n

    OpImage*Gather

    \n
    • \n
  • \n

    OpImageSparse*Gather

    \n
    • \n
  • \n

    OpImageSampleWeightedQCOM

    \n
    • \n
  • \n

    OpImageBoxFilterQCOM

    \n
    • \n
  • \n

    OpImageBlockMatch*QCOM

    \n
    • \n
\n
", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-None-10715", + "text": "If a VkSampler object that enables sampler Y′CBCR conversion is accessed in a shader, both the sampler and image accessed must be determined by constant integral expressions", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-None-10716", + "text": "If a VkSampler object that enables sampler Y′CBCR conversion is statically used, it must only be used with OpImageSample* or OpImageSparseSample* instructions", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-OpImage-10717", + "text": "An OpImage instruction must not be used on a VkSampler object that enables sampler Y′CBCR conversion", + "page": "appendices/spirvenv.html" + }, + { + "vuid": "VUID-RuntimeSpirv-ConstOffset-10718", + "text": "If a VkSampler object that enables sampler Y′CBCR conversion is statically used, it must not use the ConstOffset or Offset operands", + "page": "appendices/spirvenv.html" } ] }, diff --git a/registry/vk.xml b/registry/vk.xml index 7a34081..69ba9b0 100755 --- a/registry/vk.xml +++ b/registry/vk.xml @@ -179,11 +179,11 @@ branch of the member gitlab server. #define VKSC_API_VERSION_1_0 VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, 0)// Patch version should always be set to 0 // Version of this file -#define VK_HEADER_VERSION 311 +#define VK_HEADER_VERSION 312 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION) // Version of this file -#define VK_HEADER_VERSION 17 +#define VK_HEADER_VERSION 18 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(VKSC_API_VARIANT, 1, 0, VK_HEADER_VERSION) @@ -497,6 +497,7 @@ typedef void* MTLSharedEvent_id; typedef VkFlags VkPresentScalingFlagsEXT; typedef VkFlags VkPresentGravityFlagsEXT; typedef VkFlags VkShaderCreateFlagsEXT; + typedef VkFlags VkTileShadingRenderPassFlagsQCOM; typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagsARM; Video Core extension @@ -849,6 +850,7 @@ typedef void* MTLSharedEvent_id; + WSI extensions @@ -5197,7 +5199,7 @@ typedef void* MTLSharedEvent_id; void* pNext VkBool32 fragmentDensityMapOffset - + VkStructureType sType void* pNext @@ -5218,7 +5220,7 @@ typedef void* MTLSharedEvent_id; void* pNext VkExtent2D fragmentDensityOffsetGranularity - + VkStructureType sType const void* pNext @@ -5230,7 +5232,7 @@ typedef void* MTLSharedEvent_id; uint32_t fragmentDensityOffsetCount const VkOffset2D* pFragmentDensityOffsets - + VkStructureType sType void* pNext @@ -10178,6 +10180,50 @@ typedef void* MTLSharedEvent_id; VkCooperativeVectorMatrixLayoutNV dstLayout size_t dstStride + + VkStructureType sType + void* 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 + + + VkStructureType sType + void* pNext + uint32_t maxApronSize + VkBool32 preferNonCoherent + VkExtent2D tileGranularity + VkExtent2D maxTileShadingRate + + + VkStructureType sType + const void* pNext + VkTileShadingRenderPassFlagsQCOM flags + VkExtent2D tileApronSize + + + VkStructureType sType + const void* pNext + + + VkStructureType sType + const void* pNext + + + VkStructureType sType + const void* pNext + VkStructureType sType const void* pNext @@ -10189,6 +10235,28 @@ typedef void* MTLSharedEvent_id; void* pNext VkBool32 presentMetering + + VkStructureType sType + const void* pNext + uint32_t reservedExternalQueues + + + VkStructureType sType + const void* pNext + VkQueue preferredQueue + + + VkStructureType sType + const void* pNext + uint32_t deviceIndex + + + VkStructureType sType + void* pNext + uint32_t externalDataSize + uint32_t maxExternalQueues + + VK_DEFINE_HANDLE(VkExternalComputeQueueNV) @@ -12384,6 +12452,10 @@ typedef void* MTLSharedEvent_id; + + + + @@ -13249,14 +13321,14 @@ typedef void* MTLSharedEvent_id; uint32_t drawCount uint32_t stride - + void vkCmdDispatch VkCommandBuffer commandBuffer uint32_t groupCountX uint32_t groupCountY uint32_t groupCountZ - + void vkCmdDispatchIndirect VkCommandBuffer commandBuffer VkBuffer buffer @@ -14283,7 +14355,7 @@ typedef void* MTLSharedEvent_id; const VkAcquireNextImageInfoKHR* pAcquireInfo uint32_t* pImageIndex - + void vkCmdDispatchBase VkCommandBuffer commandBuffer uint32_t baseGroupX @@ -16710,6 +16782,39 @@ typedef void* MTLSharedEvent_id; uint32_t infoCount const VkConvertCooperativeVectorMatrixInfoNV* pInfos + + void vkCmdDispatchTileQCOM + VkCommandBuffer commandBuffer + + + void vkCmdBeginPerTileExecutionQCOM + VkCommandBuffer commandBuffer + const VkPerTileBeginInfoQCOM* pPerTileBeginInfo + + + void vkCmdEndPerTileExecutionQCOM + VkCommandBuffer commandBuffer + const VkPerTileEndInfoQCOM* pPerTileEndInfo + + + VkResult vkCreateExternalComputeQueueNV + VkDevice device + const VkExternalComputeQueueCreateInfoNV* pCreateInfo + const VkAllocationCallbacks* pAllocator + VkExternalComputeQueueNV* pExternalQueue + + + void vkDestroyExternalComputeQueueNV + VkDevice device + VkExternalComputeQueueNV externalQueue + const VkAllocationCallbacks* pAllocator + + + void vkGetExternalComputeQueueDataNV + VkExternalComputeQueueNV externalQueue + VkExternalComputeQueueDataParamsNV* params + void* pData + @@ -23102,14 +23207,41 @@ typedef void* MTLSharedEvent_id; - + - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -26525,10 +26657,25 @@ typedef void* MTLSharedEvent_id; - + - - + + + + + + + + + + + + + + + + + @@ -27187,6 +27334,39 @@ typedef void* MTLSharedEvent_id; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -27413,7 +27593,7 @@ typedef void* MTLSharedEvent_id; - + @@ -27455,7 +27635,7 @@ typedef void* MTLSharedEvent_id; - + @@ -27494,7 +27674,7 @@ typedef void* MTLSharedEvent_id; - + @@ -27888,7 +28068,7 @@ typedef void* MTLSharedEvent_id; - + @@ -27900,7 +28080,7 @@ typedef void* MTLSharedEvent_id; - + @@ -27912,7 +28092,7 @@ typedef void* MTLSharedEvent_id; - + @@ -27948,7 +28128,7 @@ typedef void* MTLSharedEvent_id; - + @@ -27970,7 +28150,7 @@ typedef void* MTLSharedEvent_id; - + @@ -27982,7 +28162,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28008,7 +28188,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28020,7 +28200,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28032,7 +28212,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28044,7 +28224,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28056,7 +28236,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28068,7 +28248,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28080,7 +28260,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28092,7 +28272,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28104,7 +28284,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28116,7 +28296,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28128,7 +28308,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28140,7 +28320,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28152,7 +28332,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28164,7 +28344,7 @@ typedef void* MTLSharedEvent_id; - + @@ -28420,25 +28600,25 @@ typedef void* MTLSharedEvent_id; - + - + - + - + @@ -28865,6 +29045,9 @@ typedef void* MTLSharedEvent_id; + + + @@ -29425,6 +29608,9 @@ typedef void* MTLSharedEvent_id; + + + @@ -29574,11 +29760,11 @@ typedef void* MTLSharedEvent_id; - + - + Fragment shader stage is added by the VK_EXT_shader_tile_image extension @@ -29695,6 +29881,12 @@ typedef void* MTLSharedEvent_id; + + + + + + VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT