diff --git a/include/vulkan/vulkan.hpp b/include/vulkan/vulkan.hpp index 3e9a8a0..9e0994d 100644 --- a/include/vulkan/vulkan.hpp +++ b/include/vulkan/vulkan.hpp @@ -114,7 +114,7 @@ extern "C" __declspec( dllimport ) FARPROC __stdcall GetProcAddress( HINSTANCE h # include #endif -static_assert( VK_HEADER_VERSION == 245, "Wrong VK_HEADER_VERSION!" ); +static_assert( VK_HEADER_VERSION == 246, "Wrong VK_HEADER_VERSION!" ); // 32-bit vulkan is not typesafe for non-dispatchable handles, so don't allow copy constructors on this platform by default. // To enable this feature on 32-bit platforms please define VULKAN_HPP_TYPESAFE_CONVERSION @@ -140,13 +140,16 @@ static_assert( VK_HEADER_VERSION == 245, "Wrong VK_HEADER_VERSION!" ); # undef MemoryBarrier #endif +#if defined( __GNUC__ ) +# define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ ) +#endif + #if !defined( VULKAN_HPP_HAS_UNRESTRICTED_UNIONS ) # if defined( __clang__ ) # if __has_feature( cxx_unrestricted_unions ) # define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS # endif # elif defined( __GNUC__ ) -# define GCC_VERSION ( __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ ) # if 40600 <= GCC_VERSION # define VULKAN_HPP_HAS_UNRESTRICTED_UNIONS # endif @@ -181,11 +184,16 @@ static_assert( VK_HEADER_VERSION == 245, "Wrong VK_HEADER_VERSION!" ); #if defined( __cpp_constexpr ) # define VULKAN_HPP_CONSTEXPR constexpr -# if __cpp_constexpr >= 201304 +# if 201304 <= __cpp_constexpr # define VULKAN_HPP_CONSTEXPR_14 constexpr # else # define VULKAN_HPP_CONSTEXPR_14 # endif +# if ( 201907 <= __cpp_constexpr ) && ( !defined( __GNUC__ ) || ( 110300 < GCC_VERSION ) ) +# define VULKAN_HPP_CONSTEXPR_20 constexpr +# else +# define VULKAN_HPP_CONSTEXPR_20 +# endif # define VULKAN_HPP_CONST_OR_CONSTEXPR constexpr #else # define VULKAN_HPP_CONSTEXPR @@ -5842,6 +5850,35 @@ namespace VULKAN_HPP_NAMESPACE return ::vkCmdOpticalFlowExecuteNV( commandBuffer, session, pExecuteInfo ); } + //=== VK_EXT_shader_object === + + VkResult vkCreateShadersEXT( VkDevice device, + uint32_t createInfoCount, + const VkShaderCreateInfoEXT * pCreateInfos, + const VkAllocationCallbacks * pAllocator, + VkShaderEXT * pShaders ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCreateShadersEXT( device, createInfoCount, pCreateInfos, pAllocator, pShaders ); + } + + void vkDestroyShaderEXT( VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks * pAllocator ) const VULKAN_HPP_NOEXCEPT + { + return ::vkDestroyShaderEXT( device, shader, pAllocator ); + } + + VkResult vkGetShaderBinaryDataEXT( VkDevice device, VkShaderEXT shader, size_t * pDataSize, void * pData ) const VULKAN_HPP_NOEXCEPT + { + return ::vkGetShaderBinaryDataEXT( device, shader, pDataSize, pData ); + } + + void vkCmdBindShadersEXT( VkCommandBuffer commandBuffer, + uint32_t stageCount, + const VkShaderStageFlagBits * pStages, + const VkShaderEXT * pShaders ) const VULKAN_HPP_NOEXCEPT + { + return ::vkCmdBindShadersEXT( commandBuffer, stageCount, pStages, pShaders ); + } + //=== VK_QCOM_tile_properties === VkResult vkGetFramebufferTilePropertiesQCOM( VkDevice device, @@ -6487,6 +6524,13 @@ namespace VULKAN_HPP_NAMESPACE CompressionExhaustedEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorCompressionExhaustedEXT ), message ) {} }; + class IncompatibleShaderBinaryEXTError : public SystemError + { + public: + IncompatibleShaderBinaryEXTError( std::string const & message ) : SystemError( make_error_code( Result::eErrorIncompatibleShaderBinaryEXT ), message ) {} + IncompatibleShaderBinaryEXTError( char const * message ) : SystemError( make_error_code( Result::eErrorIncompatibleShaderBinaryEXT ), message ) {} + }; + namespace { [[noreturn]] void throwResultException( Result result, char const * message ) @@ -6531,7 +6575,8 @@ namespace VULKAN_HPP_NAMESPACE case Result::eErrorInvalidVideoStdParametersKHR: throw InvalidVideoStdParametersKHRError( message ); # endif /*VK_ENABLE_BETA_EXTENSIONS*/ case Result::eErrorCompressionExhaustedEXT: throw CompressionExhaustedEXTError( message ); - default: throw SystemError( make_error_code( result ) ); + case Result::eErrorIncompatibleShaderBinaryEXT: throw IncompatibleShaderBinaryEXTError( message ); + default: throw SystemError( make_error_code( result ), message ); } } } // namespace @@ -7785,6 +7830,14 @@ namespace VULKAN_HPP_NAMESPACE }; }; template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> struct StructExtends { enum @@ -11765,6 +11818,32 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_EXT_shader_tile_image === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_EXT_opacity_micromap === template <> struct StructExtends @@ -12375,6 +12454,32 @@ namespace VULKAN_HPP_NAMESPACE }; }; + //=== VK_EXT_shader_object === + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + template <> + struct StructExtends + { + enum + { + value = true + }; + }; + //=== VK_QCOM_tile_properties === template <> struct StructExtends @@ -13710,6 +13815,12 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV = 0; PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV = 0; + //=== VK_EXT_shader_object === + PFN_vkCreateShadersEXT vkCreateShadersEXT = 0; + PFN_vkDestroyShaderEXT vkDestroyShaderEXT = 0; + PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0; + PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT = 0; + //=== VK_QCOM_tile_properties === PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0; PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0; @@ -14992,6 +15103,12 @@ namespace VULKAN_HPP_NAMESPACE vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetInstanceProcAddr( instance, "vkBindOpticalFlowSessionImageNV" ) ); vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetInstanceProcAddr( instance, "vkCmdOpticalFlowExecuteNV" ) ); + //=== VK_EXT_shader_object === + vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetInstanceProcAddr( instance, "vkCreateShadersEXT" ) ); + vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetInstanceProcAddr( instance, "vkDestroyShaderEXT" ) ); + vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetInstanceProcAddr( instance, "vkGetShaderBinaryDataEXT" ) ); + vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetInstanceProcAddr( instance, "vkCmdBindShadersEXT" ) ); + //=== VK_QCOM_tile_properties === vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetInstanceProcAddr( instance, "vkGetFramebufferTilePropertiesQCOM" ) ); vkGetDynamicRenderingTilePropertiesQCOM = @@ -15943,6 +16060,12 @@ namespace VULKAN_HPP_NAMESPACE vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetDeviceProcAddr( device, "vkBindOpticalFlowSessionImageNV" ) ); vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetDeviceProcAddr( device, "vkCmdOpticalFlowExecuteNV" ) ); + //=== VK_EXT_shader_object === + vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetDeviceProcAddr( device, "vkCreateShadersEXT" ) ); + vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetDeviceProcAddr( device, "vkDestroyShaderEXT" ) ); + vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) ); + vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) ); + //=== VK_QCOM_tile_properties === vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) ); vkGetDynamicRenderingTilePropertiesQCOM = diff --git a/include/vulkan/vulkan_beta.h b/include/vulkan/vulkan_beta.h index a118d77..b0729cc 100644 --- a/include/vulkan/vulkan_beta.h +++ b/include/vulkan/vulkan_beta.h @@ -485,6 +485,51 @@ typedef struct VkVideoEncodeH265RateControlLayerInfoEXT { } VkVideoEncodeH265RateControlLayerInfoEXT; + +#define VK_NV_displacement_micromap 1 +#define VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION 1 +#define VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME "VK_NV_displacement_micromap" + +typedef enum VkDisplacementMicromapFormatNV { + VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV = 1, + VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV = 2, + VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV = 3, + VK_DISPLACEMENT_MICROMAP_FORMAT_MAX_ENUM_NV = 0x7FFFFFFF +} VkDisplacementMicromapFormatNV; +typedef struct VkPhysicalDeviceDisplacementMicromapFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 displacementMicromap; +} VkPhysicalDeviceDisplacementMicromapFeaturesNV; + +typedef struct VkPhysicalDeviceDisplacementMicromapPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxDisplacementMicromapSubdivisionLevel; +} VkPhysicalDeviceDisplacementMicromapPropertiesNV; + +typedef struct VkAccelerationStructureTrianglesDisplacementMicromapNV { + VkStructureType sType; + void* pNext; + VkFormat displacementBiasAndScaleFormat; + VkFormat displacementVectorFormat; + VkDeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer; + VkDeviceSize displacementBiasAndScaleStride; + VkDeviceOrHostAddressConstKHR displacementVectorBuffer; + VkDeviceSize displacementVectorStride; + VkDeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags; + VkDeviceSize displacedMicromapPrimitiveFlagsStride; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR indexBuffer; + VkDeviceSize indexStride; + uint32_t baseTriangle; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts; + const VkMicromapUsageEXT* const* ppUsageCounts; + VkMicromapEXT micromap; +} VkAccelerationStructureTrianglesDisplacementMicromapNV; + + #ifdef __cplusplus } #endif diff --git a/include/vulkan/vulkan_core.h b/include/vulkan/vulkan_core.h index 3a9af4f..c093696 100644 --- a/include/vulkan/vulkan_core.h +++ b/include/vulkan/vulkan_core.h @@ -68,7 +68,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 245 +#define VK_HEADER_VERSION 246 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) @@ -185,6 +185,7 @@ typedef enum VkResult { VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR = -1000299000, #endif VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000, + VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, @@ -933,6 +934,8 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT = 1000395000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT = 1000395001, VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT = 1000396000, VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT = 1000396001, VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT = 1000396002, @@ -999,6 +1002,9 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = 1000466000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT = 1000482000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT = 1000482001, + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT = 1000482002, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000, VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC = 1000485000, @@ -1186,6 +1192,7 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, + VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF } VkStructureType; @@ -1290,6 +1297,7 @@ typedef enum VkObjectType { VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1000366000, VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000, VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, + VK_OBJECT_TYPE_SHADER_EXT = 1000482000, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, @@ -15234,6 +15242,27 @@ typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT { +#define VK_EXT_shader_tile_image 1 +#define VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION 1 +#define VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME "VK_EXT_shader_tile_image" +typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderTileImageColorReadAccess; + VkBool32 shaderTileImageDepthReadAccess; + VkBool32 shaderTileImageStencilReadAccess; +} VkPhysicalDeviceShaderTileImageFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderTileImageCoherentReadAccelerated; + VkBool32 shaderTileImageReadSampleFromPixelRateInvocation; + VkBool32 shaderTileImageReadFromHelperInvocation; +} VkPhysicalDeviceShaderTileImagePropertiesEXT; + + + #define VK_EXT_opacity_micromap 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkMicromapEXT) #define VK_EXT_OPACITY_MICROMAP_SPEC_VERSION 2 @@ -15505,51 +15534,6 @@ VKAPI_ATTR void VKAPI_CALL vkGetMicromapBuildSizesEXT( #endif -#define VK_NV_displacement_micromap 1 -#define VK_NV_DISPLACEMENT_MICROMAP_SPEC_VERSION 1 -#define VK_NV_DISPLACEMENT_MICROMAP_EXTENSION_NAME "VK_NV_displacement_micromap" - -typedef enum VkDisplacementMicromapFormatNV { - VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV = 1, - VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV = 2, - VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV = 3, - VK_DISPLACEMENT_MICROMAP_FORMAT_MAX_ENUM_NV = 0x7FFFFFFF -} VkDisplacementMicromapFormatNV; -typedef struct VkPhysicalDeviceDisplacementMicromapFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 displacementMicromap; -} VkPhysicalDeviceDisplacementMicromapFeaturesNV; - -typedef struct VkPhysicalDeviceDisplacementMicromapPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t maxDisplacementMicromapSubdivisionLevel; -} VkPhysicalDeviceDisplacementMicromapPropertiesNV; - -typedef struct VkAccelerationStructureTrianglesDisplacementMicromapNV { - VkStructureType sType; - void* pNext; - VkFormat displacementBiasAndScaleFormat; - VkFormat displacementVectorFormat; - VkDeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer; - VkDeviceSize displacementBiasAndScaleStride; - VkDeviceOrHostAddressConstKHR displacementVectorBuffer; - VkDeviceSize displacementVectorStride; - VkDeviceOrHostAddressConstKHR displacedMicromapPrimitiveFlags; - VkDeviceSize displacedMicromapPrimitiveFlagsStride; - VkIndexType indexType; - VkDeviceOrHostAddressConstKHR indexBuffer; - VkDeviceSize indexStride; - uint32_t baseTriangle; - uint32_t usageCountsCount; - const VkMicromapUsageEXT* pUsageCounts; - const VkMicromapUsageEXT* const* ppUsageCounts; - VkMicromapEXT micromap; -} VkAccelerationStructureTrianglesDisplacementMicromapNV; - - - #define VK_EXT_load_store_op_none 1 #define VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION 1 #define VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_EXT_load_store_op_none" @@ -16458,6 +16442,92 @@ typedef struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT { +#define VK_EXT_shader_object 1 +VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderEXT) +#define VK_EXT_SHADER_OBJECT_SPEC_VERSION 1 +#define VK_EXT_SHADER_OBJECT_EXTENSION_NAME "VK_EXT_shader_object" + +typedef enum VkShaderCodeTypeEXT { + VK_SHADER_CODE_TYPE_BINARY_EXT = 0, + VK_SHADER_CODE_TYPE_SPIRV_EXT = 1, + VK_SHADER_CODE_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkShaderCodeTypeEXT; + +typedef enum VkShaderCreateFlagBitsEXT { + VK_SHADER_CREATE_LINK_STAGE_BIT_EXT = 0x00000001, + VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000002, + VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000004, + VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT = 0x00000008, + VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT = 0x00000010, + VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 0x00000020, + VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00000040, + VK_SHADER_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkShaderCreateFlagBitsEXT; +typedef VkFlags VkShaderCreateFlagsEXT; +typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderObject; +} VkPhysicalDeviceShaderObjectFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT { + VkStructureType sType; + void* pNext; + uint8_t shaderBinaryUUID[VK_UUID_SIZE]; + uint32_t shaderBinaryVersion; +} VkPhysicalDeviceShaderObjectPropertiesEXT; + +typedef struct VkShaderCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkShaderCreateFlagsEXT flags; + VkShaderStageFlagBits stage; + VkShaderStageFlags nextStage; + VkShaderCodeTypeEXT codeType; + size_t codeSize; + const void* pCode; + const char* pName; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; + const VkSpecializationInfo* pSpecializationInfo; +} VkShaderCreateInfoEXT; + +typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkShaderRequiredSubgroupSizeCreateInfoEXT; + +typedef VkResult (VKAPI_PTR *PFN_vkCreateShadersEXT)(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders); +typedef void (VKAPI_PTR *PFN_vkDestroyShaderEXT)(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator); +typedef VkResult (VKAPI_PTR *PFN_vkGetShaderBinaryDataEXT)(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData); +typedef void (VKAPI_PTR *PFN_vkCmdBindShadersEXT)(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkCreateShadersEXT( + VkDevice device, + uint32_t createInfoCount, + const VkShaderCreateInfoEXT* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkShaderEXT* pShaders); + +VKAPI_ATTR void VKAPI_CALL vkDestroyShaderEXT( + VkDevice device, + VkShaderEXT shader, + const VkAllocationCallbacks* pAllocator); + +VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderBinaryDataEXT( + VkDevice device, + VkShaderEXT shader, + size_t* pDataSize, + void* pData); + +VKAPI_ATTR void VKAPI_CALL vkCmdBindShadersEXT( + VkCommandBuffer commandBuffer, + uint32_t stageCount, + const VkShaderStageFlagBits* pStages, + const VkShaderEXT* pShaders); +#endif + + #define VK_QCOM_tile_properties 1 #define VK_QCOM_TILE_PROPERTIES_SPEC_VERSION 1 #define VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME "VK_QCOM_tile_properties" diff --git a/include/vulkan/vulkan_enums.hpp b/include/vulkan/vulkan_enums.hpp index 5a669c8..133ee66 100644 --- a/include/vulkan/vulkan_enums.hpp +++ b/include/vulkan/vulkan_enums.hpp @@ -80,7 +80,8 @@ namespace VULKAN_HPP_NAMESPACE #if defined( VK_ENABLE_BETA_EXTENSIONS ) eErrorInvalidVideoStdParametersKHR = VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR, #endif /*VK_ENABLE_BETA_EXTENSIONS*/ - eErrorCompressionExhaustedEXT = VK_ERROR_COMPRESSION_EXHAUSTED_EXT + eErrorCompressionExhaustedEXT = VK_ERROR_COMPRESSION_EXHAUSTED_EXT, + eErrorIncompatibleShaderBinaryEXT = VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT }; enum class StructureType @@ -989,6 +990,8 @@ namespace VULKAN_HPP_NAMESPACE ePhysicalDeviceMultiDrawFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT, ePhysicalDeviceMultiDrawPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT, ePhysicalDeviceImage2DViewOf3DFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT, + ePhysicalDeviceShaderTileImageFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT, + ePhysicalDeviceShaderTileImagePropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT, eMicromapBuildInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT, eMicromapVersionInfoEXT = VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT, eCopyMicromapInfoEXT = VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT, @@ -1055,6 +1058,10 @@ namespace VULKAN_HPP_NAMESPACE eOpticalFlowSessionCreatePrivateDataInfoNV = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV, ePhysicalDeviceLegacyDitheringFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT, ePhysicalDevicePipelineProtectedAccessFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT, + ePhysicalDeviceShaderObjectFeaturesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT, + ePhysicalDeviceShaderObjectPropertiesEXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT, + eShaderCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT, + eShaderRequiredSubgroupSizeCreateInfoEXT = VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT, ePhysicalDeviceTilePropertiesFeaturesQCOM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM, eTilePropertiesQCOM = VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM, ePhysicalDeviceAmigoProfilingFeaturesSEC = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC, @@ -1130,7 +1137,8 @@ namespace VULKAN_HPP_NAMESPACE eBufferCollectionFUCHSIA = VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA, #endif /*VK_USE_PLATFORM_FUCHSIA*/ eMicromapEXT = VK_OBJECT_TYPE_MICROMAP_EXT, - eOpticalFlowSessionNV = VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV + eOpticalFlowSessionNV = VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV, + eShaderEXT = VK_OBJECT_TYPE_SHADER_EXT }; enum class VendorId @@ -6471,6 +6479,37 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR OpticalFlowExecuteFlagsNV allFlags = OpticalFlowExecuteFlagBitsNV::eDisableTemporalHints; }; + //=== VK_EXT_shader_object === + + enum class ShaderCreateFlagBitsEXT : VkShaderCreateFlagsEXT + { + eLinkStage = VK_SHADER_CREATE_LINK_STAGE_BIT_EXT, + eAllowVaryingSubgroupSize = VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT, + eRequireFullSubgroups = VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT, + eNoTaskShader = VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT, + eDispatchBase = VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT, + eFragmentShadingRateAttachment = VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT, + eFragmentDensityMapAttachment = VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT + }; + + using ShaderCreateFlagsEXT = Flags; + + template <> + struct FlagTraits + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool isBitmask = true; + static VULKAN_HPP_CONST_OR_CONSTEXPR ShaderCreateFlagsEXT allFlags = + ShaderCreateFlagBitsEXT::eLinkStage | ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize | ShaderCreateFlagBitsEXT::eRequireFullSubgroups | + ShaderCreateFlagBitsEXT::eNoTaskShader | ShaderCreateFlagBitsEXT::eDispatchBase | ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment | + ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment; + }; + + enum class ShaderCodeTypeEXT + { + eBinary = VK_SHADER_CODE_TYPE_BINARY_EXT, + eSpirv = VK_SHADER_CODE_TYPE_SPIRV_EXT + }; + //=== VK_NV_ray_tracing_invocation_reorder === enum class RayTracingInvocationReorderModeNV diff --git a/include/vulkan/vulkan_extension_inspection.hpp b/include/vulkan/vulkan_extension_inspection.hpp new file mode 100644 index 0000000..829aadb --- /dev/null +++ b/include/vulkan/vulkan_extension_inspection.hpp @@ -0,0 +1,321 @@ +// Copyright 2015-2023 The Khronos Group Inc. +// +// SPDX-License-Identifier: Apache-2.0 OR MIT +// + +// This header is generated from the Khronos Vulkan XML API Registry. + +#ifndef VULKAN_EXTENSION_INSPECTION_HPP +#define VULKAN_EXTENSION_INSPECTION_HPP + +#include + +namespace VULKAN_HPP_NAMESPACE +{ + //====================================== + //=== Extension inspection functions === + //====================================== + + VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & name ); + VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & name ); + VULKAN_HPP_CONSTEXPR_20 bool isExtensionDeprecated( std::string const & name ); + VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & name ); + + //===================================================== + //=== Extension inspection function implementations === + //===================================================== + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 std::string getExtensionDeprecatedBy( std::string const & name ) + { + if ( name == "VK_EXT_debug_report" ) + { + return "VK_EXT_debug_utils"; + } + if ( name == "VK_NV_glsl_shader" ) + { + return ""; + } + if ( name == "VK_NV_dedicated_allocation" ) + { + return "VK_KHR_dedicated_allocation"; + } + if ( name == "VK_AMD_gpu_shader_half_float" ) + { + return "VK_KHR_shader_float16_int8"; + } + if ( name == "VK_IMG_format_pvrtc" ) + { + return ""; + } + if ( name == "VK_NV_external_memory_capabilities" ) + { + return "VK_KHR_external_memory_capabilities"; + } + if ( name == "VK_NV_external_memory" ) + { + return "VK_KHR_external_memory"; + } +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + if ( name == "VK_NV_external_memory_win32" ) + { + return "VK_KHR_external_memory_win32"; + } +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + if ( name == "VK_EXT_validation_flags" ) + { + return "VK_EXT_validation_features"; + } + if ( name == "VK_EXT_shader_subgroup_ballot" ) + { + return "VK_VERSION_1_2"; + } + if ( name == "VK_EXT_shader_subgroup_vote" ) + { + return "VK_VERSION_1_1"; + } +#if defined( VK_USE_PLATFORM_IOS_MVK ) + if ( name == "VK_MVK_ios_surface" ) + { + return "VK_EXT_metal_surface"; + } +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + if ( name == "VK_MVK_macos_surface" ) + { + return "VK_EXT_metal_surface"; + } +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + if ( name == "VK_AMD_gpu_shader_int16" ) + { + return "VK_KHR_shader_float16_int8"; + } + if ( name == "VK_EXT_buffer_device_address" ) + { + return "VK_KHR_buffer_device_address"; + } + return ""; + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isDeviceExtension( std::string const & name ) + { + return ( name == "VK_KHR_swapchain" ) || ( name == "VK_KHR_display_swapchain" ) || ( name == "VK_NV_glsl_shader" ) || + ( name == "VK_EXT_depth_range_unrestricted" ) || ( name == "VK_KHR_sampler_mirror_clamp_to_edge" ) || ( name == "VK_IMG_filter_cubic" ) || + ( name == "VK_AMD_rasterization_order" ) || ( name == "VK_AMD_shader_trinary_minmax" ) || ( name == "VK_AMD_shader_explicit_vertex_parameter" ) || + ( name == "VK_EXT_debug_marker" ) || ( name == "VK_KHR_video_queue" ) || ( name == "VK_KHR_video_decode_queue" ) || + ( name == "VK_AMD_gcn_shader" ) || ( name == "VK_NV_dedicated_allocation" ) || ( name == "VK_EXT_transform_feedback" ) || + ( name == "VK_NVX_binary_import" ) || ( name == "VK_NVX_image_view_handle" ) || ( name == "VK_AMD_draw_indirect_count" ) || + ( name == "VK_AMD_negative_viewport_height" ) || ( name == "VK_AMD_gpu_shader_half_float" ) || ( name == "VK_AMD_shader_ballot" ) || +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + ( name == "VK_EXT_video_encode_h264" ) || ( name == "VK_EXT_video_encode_h265" ) || +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + ( name == "VK_KHR_video_decode_h264" ) || ( name == "VK_AMD_texture_gather_bias_lod" ) || ( name == "VK_AMD_shader_info" ) || + ( name == "VK_KHR_dynamic_rendering" ) || ( name == "VK_AMD_shader_image_load_store_lod" ) || ( name == "VK_NV_corner_sampled_image" ) || + ( name == "VK_KHR_multiview" ) || ( name == "VK_IMG_format_pvrtc" ) || ( name == "VK_NV_external_memory" ) || +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + ( name == "VK_NV_external_memory_win32" ) || ( name == "VK_NV_win32_keyed_mutex" ) || +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + ( name == "VK_KHR_device_group" ) || ( name == "VK_KHR_shader_draw_parameters" ) || ( name == "VK_EXT_shader_subgroup_ballot" ) || + ( name == "VK_EXT_shader_subgroup_vote" ) || ( name == "VK_EXT_texture_compression_astc_hdr" ) || ( name == "VK_EXT_astc_decode_mode" ) || + ( name == "VK_EXT_pipeline_robustness" ) || ( name == "VK_KHR_maintenance1" ) || ( name == "VK_KHR_external_memory" ) || +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + ( name == "VK_KHR_external_memory_win32" ) || +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + ( name == "VK_KHR_external_memory_fd" ) || +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + ( name == "VK_KHR_win32_keyed_mutex" ) || +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + ( name == "VK_KHR_external_semaphore" ) || +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + ( name == "VK_KHR_external_semaphore_win32" ) || +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + ( name == "VK_KHR_external_semaphore_fd" ) || ( name == "VK_KHR_push_descriptor" ) || ( name == "VK_EXT_conditional_rendering" ) || + ( name == "VK_KHR_shader_float16_int8" ) || ( name == "VK_KHR_16bit_storage" ) || ( name == "VK_KHR_incremental_present" ) || + ( name == "VK_KHR_descriptor_update_template" ) || ( name == "VK_NV_clip_space_w_scaling" ) || ( name == "VK_EXT_display_control" ) || + ( name == "VK_GOOGLE_display_timing" ) || ( name == "VK_NV_sample_mask_override_coverage" ) || ( name == "VK_NV_geometry_shader_passthrough" ) || + ( name == "VK_NV_viewport_array2" ) || ( name == "VK_NVX_multiview_per_view_attributes" ) || ( name == "VK_NV_viewport_swizzle" ) || + ( name == "VK_EXT_discard_rectangles" ) || ( name == "VK_EXT_conservative_rasterization" ) || ( name == "VK_EXT_depth_clip_enable" ) || + ( name == "VK_EXT_hdr_metadata" ) || ( name == "VK_KHR_imageless_framebuffer" ) || ( name == "VK_KHR_create_renderpass2" ) || + ( name == "VK_KHR_shared_presentable_image" ) || ( name == "VK_KHR_external_fence" ) || +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + ( name == "VK_KHR_external_fence_win32" ) || +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + ( name == "VK_KHR_external_fence_fd" ) || ( name == "VK_KHR_performance_query" ) || ( name == "VK_KHR_maintenance2" ) || + ( name == "VK_KHR_variable_pointers" ) || ( name == "VK_EXT_external_memory_dma_buf" ) || ( name == "VK_EXT_queue_family_foreign" ) || + ( name == "VK_KHR_dedicated_allocation" ) || +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + ( name == "VK_ANDROID_external_memory_android_hardware_buffer" ) || +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ + ( name == "VK_EXT_sampler_filter_minmax" ) || ( name == "VK_KHR_storage_buffer_storage_class" ) || ( name == "VK_AMD_gpu_shader_int16" ) || + ( name == "VK_AMD_mixed_attachment_samples" ) || ( name == "VK_AMD_shader_fragment_mask" ) || ( name == "VK_EXT_inline_uniform_block" ) || + ( name == "VK_EXT_shader_stencil_export" ) || ( name == "VK_EXT_sample_locations" ) || ( name == "VK_KHR_relaxed_block_layout" ) || + ( name == "VK_KHR_get_memory_requirements2" ) || ( name == "VK_KHR_image_format_list" ) || ( name == "VK_EXT_blend_operation_advanced" ) || + ( name == "VK_NV_fragment_coverage_to_color" ) || ( name == "VK_KHR_acceleration_structure" ) || ( name == "VK_KHR_ray_tracing_pipeline" ) || + ( name == "VK_KHR_ray_query" ) || ( name == "VK_NV_framebuffer_mixed_samples" ) || ( name == "VK_NV_fill_rectangle" ) || + ( name == "VK_NV_shader_sm_builtins" ) || ( name == "VK_EXT_post_depth_coverage" ) || ( name == "VK_KHR_sampler_ycbcr_conversion" ) || + ( name == "VK_KHR_bind_memory2" ) || ( name == "VK_EXT_image_drm_format_modifier" ) || ( name == "VK_EXT_validation_cache" ) || + ( name == "VK_EXT_descriptor_indexing" ) || ( name == "VK_EXT_shader_viewport_index_layer" ) || +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + ( name == "VK_KHR_portability_subset" ) || +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + ( name == "VK_NV_shading_rate_image" ) || ( name == "VK_NV_ray_tracing" ) || ( name == "VK_NV_representative_fragment_test" ) || + ( name == "VK_KHR_maintenance3" ) || ( name == "VK_KHR_draw_indirect_count" ) || ( name == "VK_EXT_filter_cubic" ) || + ( name == "VK_QCOM_render_pass_shader_resolve" ) || ( name == "VK_EXT_global_priority" ) || ( name == "VK_KHR_shader_subgroup_extended_types" ) || + ( name == "VK_KHR_8bit_storage" ) || ( name == "VK_EXT_external_memory_host" ) || ( name == "VK_AMD_buffer_marker" ) || + ( name == "VK_KHR_shader_atomic_int64" ) || ( name == "VK_KHR_shader_clock" ) || ( name == "VK_AMD_pipeline_compiler_control" ) || + ( name == "VK_EXT_calibrated_timestamps" ) || ( name == "VK_AMD_shader_core_properties" ) || ( name == "VK_KHR_video_decode_h265" ) || + ( name == "VK_KHR_global_priority" ) || ( name == "VK_AMD_memory_overallocation_behavior" ) || ( name == "VK_EXT_vertex_attribute_divisor" ) || +#if defined( VK_USE_PLATFORM_GGP ) + ( name == "VK_GGP_frame_token" ) || +#endif /*VK_USE_PLATFORM_GGP*/ + ( name == "VK_EXT_pipeline_creation_feedback" ) || ( name == "VK_KHR_driver_properties" ) || ( name == "VK_KHR_shader_float_controls" ) || + ( name == "VK_NV_shader_subgroup_partitioned" ) || ( name == "VK_KHR_depth_stencil_resolve" ) || ( name == "VK_KHR_swapchain_mutable_format" ) || + ( name == "VK_NV_compute_shader_derivatives" ) || ( name == "VK_NV_mesh_shader" ) || ( name == "VK_NV_fragment_shader_barycentric" ) || + ( name == "VK_NV_shader_image_footprint" ) || ( name == "VK_NV_scissor_exclusive" ) || ( name == "VK_NV_device_diagnostic_checkpoints" ) || + ( name == "VK_KHR_timeline_semaphore" ) || ( name == "VK_INTEL_shader_integer_functions2" ) || ( name == "VK_INTEL_performance_query" ) || + ( name == "VK_KHR_vulkan_memory_model" ) || ( name == "VK_EXT_pci_bus_info" ) || ( name == "VK_AMD_display_native_hdr" ) || + ( name == "VK_KHR_shader_terminate_invocation" ) || ( name == "VK_EXT_fragment_density_map" ) || ( name == "VK_EXT_scalar_block_layout" ) || + ( name == "VK_GOOGLE_hlsl_functionality1" ) || ( name == "VK_GOOGLE_decorate_string" ) || ( name == "VK_EXT_subgroup_size_control" ) || + ( name == "VK_KHR_fragment_shading_rate" ) || ( name == "VK_AMD_shader_core_properties2" ) || ( name == "VK_AMD_device_coherent_memory" ) || + ( name == "VK_EXT_shader_image_atomic_int64" ) || ( name == "VK_KHR_spirv_1_4" ) || ( name == "VK_EXT_memory_budget" ) || + ( name == "VK_EXT_memory_priority" ) || ( name == "VK_NV_dedicated_allocation_image_aliasing" ) || + ( name == "VK_KHR_separate_depth_stencil_layouts" ) || ( name == "VK_EXT_buffer_device_address" ) || ( name == "VK_EXT_tooling_info" ) || + ( name == "VK_EXT_separate_stencil_usage" ) || ( name == "VK_KHR_present_wait" ) || ( name == "VK_NV_cooperative_matrix" ) || + ( name == "VK_NV_coverage_reduction_mode" ) || ( name == "VK_EXT_fragment_shader_interlock" ) || ( name == "VK_EXT_ycbcr_image_arrays" ) || + ( name == "VK_KHR_uniform_buffer_standard_layout" ) || ( name == "VK_EXT_provoking_vertex" ) || +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + ( name == "VK_EXT_full_screen_exclusive" ) || +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + ( name == "VK_KHR_buffer_device_address" ) || ( name == "VK_EXT_line_rasterization" ) || ( name == "VK_EXT_shader_atomic_float" ) || + ( name == "VK_EXT_host_query_reset" ) || ( name == "VK_EXT_index_type_uint8" ) || ( name == "VK_EXT_extended_dynamic_state" ) || + ( name == "VK_KHR_deferred_host_operations" ) || ( name == "VK_KHR_pipeline_executable_properties" ) || ( name == "VK_KHR_map_memory2" ) || + ( name == "VK_EXT_shader_atomic_float2" ) || ( name == "VK_EXT_swapchain_maintenance1" ) || + ( name == "VK_EXT_shader_demote_to_helper_invocation" ) || ( name == "VK_NV_device_generated_commands" ) || + ( name == "VK_NV_inherited_viewport_scissor" ) || ( name == "VK_KHR_shader_integer_dot_product" ) || ( name == "VK_EXT_texel_buffer_alignment" ) || + ( name == "VK_QCOM_render_pass_transform" ) || ( name == "VK_EXT_device_memory_report" ) || ( name == "VK_EXT_robustness2" ) || + ( name == "VK_EXT_custom_border_color" ) || ( name == "VK_GOOGLE_user_type" ) || ( name == "VK_KHR_pipeline_library" ) || + ( name == "VK_NV_present_barrier" ) || ( name == "VK_KHR_shader_non_semantic_info" ) || ( name == "VK_KHR_present_id" ) || + ( name == "VK_EXT_private_data" ) || ( name == "VK_EXT_pipeline_creation_cache_control" ) || +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + ( name == "VK_KHR_video_encode_queue" ) || +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + ( name == "VK_NV_device_diagnostics_config" ) || ( name == "VK_QCOM_render_pass_store_ops" ) || ( name == "VK_NV_low_latency" ) || +#if defined( VK_USE_PLATFORM_METAL_EXT ) + ( name == "VK_EXT_metal_objects" ) || +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + ( name == "VK_KHR_synchronization2" ) || ( name == "VK_EXT_descriptor_buffer" ) || ( name == "VK_EXT_graphics_pipeline_library" ) || + ( name == "VK_AMD_shader_early_and_late_fragment_tests" ) || ( name == "VK_KHR_fragment_shader_barycentric" ) || + ( name == "VK_KHR_shader_subgroup_uniform_control_flow" ) || ( name == "VK_KHR_zero_initialize_workgroup_memory" ) || + ( name == "VK_NV_fragment_shading_rate_enums" ) || ( name == "VK_NV_ray_tracing_motion_blur" ) || ( name == "VK_EXT_mesh_shader" ) || + ( name == "VK_EXT_ycbcr_2plane_444_formats" ) || ( name == "VK_EXT_fragment_density_map2" ) || ( name == "VK_QCOM_rotated_copy_commands" ) || + ( name == "VK_EXT_image_robustness" ) || ( name == "VK_KHR_workgroup_memory_explicit_layout" ) || ( name == "VK_KHR_copy_commands2" ) || + ( name == "VK_EXT_image_compression_control" ) || ( name == "VK_EXT_attachment_feedback_loop_layout" ) || ( name == "VK_EXT_4444_formats" ) || + ( name == "VK_EXT_device_fault" ) || ( name == "VK_ARM_rasterization_order_attachment_access" ) || ( name == "VK_EXT_rgba10x6_formats" ) || +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + ( name == "VK_NV_acquire_winrt_display" ) || +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + ( name == "VK_VALVE_mutable_descriptor_type" ) || ( name == "VK_EXT_vertex_input_dynamic_state" ) || ( name == "VK_EXT_physical_device_drm" ) || + ( name == "VK_EXT_device_address_binding_report" ) || ( name == "VK_EXT_depth_clip_control" ) || + ( name == "VK_EXT_primitive_topology_list_restart" ) || ( name == "VK_KHR_format_feature_flags2" ) || +#if defined( VK_USE_PLATFORM_FUCHSIA ) + ( name == "VK_FUCHSIA_external_memory" ) || ( name == "VK_FUCHSIA_external_semaphore" ) || ( name == "VK_FUCHSIA_buffer_collection" ) || +#endif /*VK_USE_PLATFORM_FUCHSIA*/ + ( name == "VK_HUAWEI_subpass_shading" ) || ( name == "VK_HUAWEI_invocation_mask" ) || ( name == "VK_NV_external_memory_rdma" ) || + ( name == "VK_EXT_pipeline_properties" ) || ( name == "VK_EXT_multisampled_render_to_single_sampled" ) || + ( name == "VK_EXT_extended_dynamic_state2" ) || ( name == "VK_EXT_color_write_enable" ) || ( name == "VK_EXT_primitives_generated_query" ) || + ( name == "VK_KHR_ray_tracing_maintenance1" ) || ( name == "VK_EXT_global_priority_query" ) || ( name == "VK_EXT_image_view_min_lod" ) || + ( name == "VK_EXT_multi_draw" ) || ( name == "VK_EXT_image_2d_view_of_3d" ) || ( name == "VK_EXT_shader_tile_image" ) || + ( name == "VK_EXT_opacity_micromap" ) || +#if defined( VK_ENABLE_BETA_EXTENSIONS ) + ( name == "VK_NV_displacement_micromap" ) || +#endif /*VK_ENABLE_BETA_EXTENSIONS*/ + ( name == "VK_EXT_load_store_op_none" ) || ( name == "VK_HUAWEI_cluster_culling_shader" ) || ( name == "VK_EXT_border_color_swizzle" ) || + ( name == "VK_EXT_pageable_device_local_memory" ) || ( name == "VK_KHR_maintenance4" ) || ( name == "VK_ARM_shader_core_properties" ) || + ( name == "VK_EXT_image_sliced_view_of_3d" ) || ( name == "VK_VALVE_descriptor_set_host_mapping" ) || ( name == "VK_EXT_depth_clamp_zero_one" ) || + ( name == "VK_EXT_non_seamless_cube_map" ) || ( name == "VK_QCOM_fragment_density_map_offset" ) || ( name == "VK_NV_copy_memory_indirect" ) || + ( name == "VK_NV_memory_decompression" ) || ( name == "VK_NV_linear_color_attachment" ) || + ( name == "VK_EXT_image_compression_control_swapchain" ) || ( name == "VK_QCOM_image_processing" ) || ( name == "VK_EXT_extended_dynamic_state3" ) || + ( name == "VK_EXT_subpass_merge_feedback" ) || ( name == "VK_EXT_shader_module_identifier" ) || + ( name == "VK_EXT_rasterization_order_attachment_access" ) || ( name == "VK_NV_optical_flow" ) || ( name == "VK_EXT_legacy_dithering" ) || + ( name == "VK_EXT_pipeline_protected_access" ) || ( name == "VK_EXT_shader_object" ) || ( name == "VK_QCOM_tile_properties" ) || + ( name == "VK_SEC_amigo_profiling" ) || ( name == "VK_QCOM_multiview_per_view_viewports" ) || ( name == "VK_NV_ray_tracing_invocation_reorder" ) || + ( name == "VK_EXT_mutable_descriptor_type" ) || ( name == "VK_ARM_shader_core_builtins" ) || ( name == "VK_EXT_pipeline_library_group_handles" ) || + ( name == "VK_QCOM_multiview_per_view_render_areas" ); + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isExtensionDeprecated( std::string const & name ) + { + return ( name == "VK_EXT_debug_report" ) || ( name == "VK_NV_glsl_shader" ) || ( name == "VK_NV_dedicated_allocation" ) || + ( name == "VK_AMD_gpu_shader_half_float" ) || ( name == "VK_IMG_format_pvrtc" ) || ( name == "VK_NV_external_memory_capabilities" ) || + ( name == "VK_NV_external_memory" ) || +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + ( name == "VK_NV_external_memory_win32" ) || +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + ( name == "VK_EXT_validation_flags" ) || ( name == "VK_EXT_shader_subgroup_ballot" ) || ( name == "VK_EXT_shader_subgroup_vote" ) || +#if defined( VK_USE_PLATFORM_IOS_MVK ) + ( name == "VK_MVK_ios_surface" ) || +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + ( name == "VK_MVK_macos_surface" ) || +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + ( name == "VK_AMD_gpu_shader_int16" ) || ( name == "VK_EXT_buffer_device_address" ); + } + + VULKAN_HPP_INLINE VULKAN_HPP_CONSTEXPR_20 bool isInstanceExtension( std::string const & name ) + { + return ( name == "VK_KHR_surface" ) || ( name == "VK_KHR_display" ) || +#if defined( VK_USE_PLATFORM_XLIB_KHR ) + ( name == "VK_KHR_xlib_surface" ) || +#endif /*VK_USE_PLATFORM_XLIB_KHR*/ +#if defined( VK_USE_PLATFORM_XCB_KHR ) + ( name == "VK_KHR_xcb_surface" ) || +#endif /*VK_USE_PLATFORM_XCB_KHR*/ +#if defined( VK_USE_PLATFORM_WAYLAND_KHR ) + ( name == "VK_KHR_wayland_surface" ) || +#endif /*VK_USE_PLATFORM_WAYLAND_KHR*/ +#if defined( VK_USE_PLATFORM_ANDROID_KHR ) + ( name == "VK_KHR_android_surface" ) || +#endif /*VK_USE_PLATFORM_ANDROID_KHR*/ +#if defined( VK_USE_PLATFORM_WIN32_KHR ) + ( name == "VK_KHR_win32_surface" ) || +#endif /*VK_USE_PLATFORM_WIN32_KHR*/ + ( name == "VK_EXT_debug_report" ) || +#if defined( VK_USE_PLATFORM_GGP ) + ( name == "VK_GGP_stream_descriptor_surface" ) || +#endif /*VK_USE_PLATFORM_GGP*/ + ( name == "VK_NV_external_memory_capabilities" ) || ( name == "VK_KHR_get_physical_device_properties2" ) || ( name == "VK_EXT_validation_flags" ) || +#if defined( VK_USE_PLATFORM_VI_NN ) + ( name == "VK_NN_vi_surface" ) || +#endif /*VK_USE_PLATFORM_VI_NN*/ + ( name == "VK_KHR_device_group_creation" ) || ( name == "VK_KHR_external_memory_capabilities" ) || + ( name == "VK_KHR_external_semaphore_capabilities" ) || ( name == "VK_EXT_direct_mode_display" ) || +#if defined( VK_USE_PLATFORM_XLIB_XRANDR_EXT ) + ( name == "VK_EXT_acquire_xlib_display" ) || +#endif /*VK_USE_PLATFORM_XLIB_XRANDR_EXT*/ + ( name == "VK_EXT_display_surface_counter" ) || ( name == "VK_EXT_swapchain_colorspace" ) || ( name == "VK_KHR_external_fence_capabilities" ) || + ( name == "VK_KHR_get_surface_capabilities2" ) || ( name == "VK_KHR_get_display_properties2" ) || +#if defined( VK_USE_PLATFORM_IOS_MVK ) + ( name == "VK_MVK_ios_surface" ) || +#endif /*VK_USE_PLATFORM_IOS_MVK*/ +#if defined( VK_USE_PLATFORM_MACOS_MVK ) + ( name == "VK_MVK_macos_surface" ) || +#endif /*VK_USE_PLATFORM_MACOS_MVK*/ + ( name == "VK_EXT_debug_utils" ) || +#if defined( VK_USE_PLATFORM_FUCHSIA ) + ( name == "VK_FUCHSIA_imagepipe_surface" ) || +#endif /*VK_USE_PLATFORM_FUCHSIA*/ +#if defined( VK_USE_PLATFORM_METAL_EXT ) + ( name == "VK_EXT_metal_surface" ) || +#endif /*VK_USE_PLATFORM_METAL_EXT*/ + ( name == "VK_KHR_surface_protected_capabilities" ) || ( name == "VK_EXT_validation_features" ) || ( name == "VK_EXT_headless_surface" ) || + ( name == "VK_EXT_surface_maintenance1" ) || ( name == "VK_EXT_acquire_drm_display" ) || +#if defined( VK_USE_PLATFORM_DIRECTFB_EXT ) + ( name == "VK_EXT_directfb_surface" ) || +#endif /*VK_USE_PLATFORM_DIRECTFB_EXT*/ +#if defined( VK_USE_PLATFORM_SCREEN_QNX ) + ( name == "VK_QNX_screen_surface" ) || +#endif /*VK_USE_PLATFORM_SCREEN_QNX*/ + ( name == "VK_KHR_portability_enumeration" ) || ( name == "VK_GOOGLE_surfaceless_query" ) || ( name == "VK_LUNARG_direct_driver_loading" ); + } +} // namespace VULKAN_HPP_NAMESPACE + +#endif diff --git a/include/vulkan/vulkan_funcs.hpp b/include/vulkan/vulkan_funcs.hpp index 16e98ad..c848053 100644 --- a/include/vulkan/vulkan_funcs.hpp +++ b/include/vulkan/vulkan_funcs.hpp @@ -21516,6 +21516,317 @@ namespace VULKAN_HPP_NAMESPACE } #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_EXT_shader_object === + + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result Device::createShadersEXT( uint32_t createInfoCount, + const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT * pCreateInfos, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + VULKAN_HPP_NAMESPACE::ShaderEXT * pShaders, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkCreateShadersEXT( m_device, + createInfoCount, + reinterpret_cast( pCreateInfos ), + reinterpret_cast( pAllocator ), + reinterpret_cast( pShaders ) ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + std::vector shaders( createInfos.size() ); + VkResult result = + d.vkCreateShadersEXT( m_device, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( static_cast( allocator ) ), + reinterpret_cast( shaders.data() ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT" ); + + return createResultValueType( static_cast( result ), shaders ); + } + + template ::value, int>::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + Optional allocator, + ShaderEXTAllocator & shaderEXTAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + std::vector shaders( createInfos.size(), shaderEXTAllocator ); + VkResult result = + d.vkCreateShadersEXT( m_device, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( static_cast( allocator ) ), + reinterpret_cast( shaders.data() ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXT" ); + + return createResultValueType( static_cast( result ), shaders ); + } + + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType::type + Device::createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + VULKAN_HPP_NAMESPACE::ShaderEXT shader; + VkResult result = + d.vkCreateShadersEXT( m_device, + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( static_cast( allocator ) ), + reinterpret_cast( &shader ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXT" ); + + return createResultValueType( static_cast( result ), shader ); + } + +# ifndef VULKAN_HPP_NO_SMART_HANDLE + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, ShaderEXTAllocator>>::type + Device::createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + std::vector shaders( createInfos.size() ); + VkResult result = + d.vkCreateShadersEXT( m_device, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( static_cast( allocator ) ), + reinterpret_cast( shaders.data() ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique" ); + std::vector, ShaderEXTAllocator> uniqueShaders; + uniqueShaders.reserve( createInfos.size() ); + ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & shader : shaders ) + { + uniqueShaders.push_back( UniqueHandle( shader, deleter ) ); + } + return createResultValueType( static_cast( result ), std::move( uniqueShaders ) ); + } + + template >::value, int>::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE + typename ResultValueType, ShaderEXTAllocator>>::type + Device::createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + Optional allocator, + ShaderEXTAllocator & shaderEXTAllocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + std::vector shaders( createInfos.size() ); + VkResult result = + d.vkCreateShadersEXT( m_device, + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( static_cast( allocator ) ), + reinterpret_cast( shaders.data() ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createShadersEXTUnique" ); + std::vector, ShaderEXTAllocator> uniqueShaders( shaderEXTAllocator ); + uniqueShaders.reserve( createInfos.size() ); + ObjectDestroy deleter( *this, allocator, d ); + for ( auto const & shader : shaders ) + { + uniqueShaders.push_back( UniqueHandle( shader, deleter ) ); + } + return createResultValueType( static_cast( result ), std::move( uniqueShaders ) ); + } + + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, + Optional allocator, + Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + VULKAN_HPP_NAMESPACE::ShaderEXT shader; + VkResult result = + d.vkCreateShadersEXT( m_device, + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( static_cast( allocator ) ), + reinterpret_cast( &shader ) ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::createShaderEXTUnique" ); + + return createResultValueType( static_cast( result ), + UniqueHandle( shader, ObjectDestroy( *this, allocator, d ) ) ); + } +# endif /* VULKAN_HPP_NO_SMART_HANDLE */ +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + template + VULKAN_HPP_INLINE void Device::destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyShaderEXT( m_device, static_cast( shader ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + d.vkDestroyShaderEXT( m_device, + static_cast( shader ), + reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + template + VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ShaderEXT shader, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkDestroyShaderEXT( m_device, static_cast( shader ), reinterpret_cast( pAllocator ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void Device::destroy( VULKAN_HPP_NAMESPACE::ShaderEXT shader, + Optional allocator, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + d.vkDestroyShaderEXT( m_device, + static_cast( shader ), + reinterpret_cast( static_cast( allocator ) ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE Result + Device::getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, size_t * pDataSize, void * pData, Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + return static_cast( d.vkGetShaderBinaryDataEXT( m_device, static_cast( shader ), pDataSize, pData ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + std::vector data; + size_t dataSize; + VkResult result; + do + { + result = d.vkGetShaderBinaryDataEXT( m_device, static_cast( shader ), &dataSize, nullptr ); + if ( ( result == VK_SUCCESS ) && dataSize ) + { + data.resize( dataSize ); + result = d.vkGetShaderBinaryDataEXT( m_device, static_cast( shader ), &dataSize, reinterpret_cast( data.data() ) ); + } + } while ( result == VK_INCOMPLETE ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderBinaryDataEXT" ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + if ( dataSize < data.size() ) + { + data.resize( dataSize ); + } + return createResultValueType( static_cast( result ), data ); + } + + template ::value, int>::type> + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE typename ResultValueType>::type + Device::getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d ) const + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + + std::vector data( uint8_tAllocator ); + size_t dataSize; + VkResult result; + do + { + result = d.vkGetShaderBinaryDataEXT( m_device, static_cast( shader ), &dataSize, nullptr ); + if ( ( result == VK_SUCCESS ) && dataSize ) + { + data.resize( dataSize ); + result = d.vkGetShaderBinaryDataEXT( m_device, static_cast( shader ), &dataSize, reinterpret_cast( data.data() ) ); + } + } while ( result == VK_INCOMPLETE ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::Device::getShaderBinaryDataEXT" ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + if ( dataSize < data.size() ) + { + data.resize( dataSize ); + } + return createResultValueType( static_cast( result ), data ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + + template + VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( uint32_t stageCount, + const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits * pStages, + const VULKAN_HPP_NAMESPACE::ShaderEXT * pShaders, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); + d.vkCmdBindShadersEXT( + m_commandBuffer, stageCount, reinterpret_cast( pStages ), reinterpret_cast( pShaders ) ); + } + +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & stages, + VULKAN_HPP_NAMESPACE::ArrayProxy const & shaders, + Dispatch const & d ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS + { + VULKAN_HPP_ASSERT( d.getVkHeaderVersion() == VK_HEADER_VERSION ); +# ifdef VULKAN_HPP_NO_EXCEPTIONS + VULKAN_HPP_ASSERT( stages.size() == shaders.size() ); +# else + if ( stages.size() != shaders.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindShadersEXT: stages.size() != shaders.size()" ); + } +# endif /*VULKAN_HPP_NO_EXCEPTIONS*/ + + d.vkCmdBindShadersEXT( m_commandBuffer, + stages.size(), + reinterpret_cast( stages.data() ), + reinterpret_cast( shaders.data() ) ); + } +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_QCOM_tile_properties === template diff --git a/include/vulkan/vulkan_handles.hpp b/include/vulkan/vulkan_handles.hpp index 152c877..72043b5 100644 --- a/include/vulkan/vulkan_handles.hpp +++ b/include/vulkan/vulkan_handles.hpp @@ -432,6 +432,7 @@ namespace VULKAN_HPP_NAMESPACE using PhysicalDeviceSubgroupSizeControlPropertiesEXT = PhysicalDeviceSubgroupSizeControlProperties; struct PipelineShaderStageRequiredSubgroupSizeCreateInfo; using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo; + using ShaderRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo; struct PhysicalDeviceInlineUniformBlockFeatures; using PhysicalDeviceInlineUniformBlockFeaturesEXT = PhysicalDeviceInlineUniformBlockFeatures; struct PhysicalDeviceInlineUniformBlockProperties; @@ -1432,6 +1433,10 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_image_2d_view_of_3d === struct PhysicalDeviceImage2DViewOf3DFeaturesEXT; + //=== VK_EXT_shader_tile_image === + struct PhysicalDeviceShaderTileImageFeaturesEXT; + struct PhysicalDeviceShaderTileImagePropertiesEXT; + //=== VK_EXT_opacity_micromap === struct MicromapBuildInfoEXT; struct MicromapUsageEXT; @@ -1552,6 +1557,11 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_EXT_pipeline_protected_access === struct PhysicalDevicePipelineProtectedAccessFeaturesEXT; + //=== VK_EXT_shader_object === + struct PhysicalDeviceShaderObjectFeaturesEXT; + struct PhysicalDeviceShaderObjectPropertiesEXT; + struct ShaderCreateInfoEXT; + //=== VK_QCOM_tile_properties === struct PhysicalDeviceTilePropertiesFeaturesQCOM; struct TilePropertiesQCOM; @@ -1677,6 +1687,9 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_optical_flow === class OpticalFlowSessionNV; + //=== VK_EXT_shader_object === + class ShaderEXT; + #ifndef VULKAN_HPP_NO_SMART_HANDLE //====================== //=== UNIQUE HANDLEs === @@ -2012,6 +2025,15 @@ namespace VULKAN_HPP_NAMESPACE using deleter = ObjectDestroy; }; using UniqueOpticalFlowSessionNV = UniqueHandle; + + //=== VK_EXT_shader_object === + template + class UniqueHandleTraits + { + public: + using deleter = ObjectDestroy; + }; + using UniqueShaderEXT = UniqueHandle; #endif /*VULKAN_HPP_NO_SMART_HANDLE*/ //=============== @@ -3211,6 +3233,85 @@ namespace VULKAN_HPP_NAMESPACE static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; }; + class ShaderEXT + { + public: + using CType = VkShaderEXT; + using NativeType = VkShaderEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; + + public: + VULKAN_HPP_CONSTEXPR ShaderEXT() = default; + VULKAN_HPP_CONSTEXPR ShaderEXT( std::nullptr_t ) VULKAN_HPP_NOEXCEPT {} + VULKAN_HPP_TYPESAFE_EXPLICIT ShaderEXT( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT : m_shaderEXT( shaderEXT ) {} + +#if defined( VULKAN_HPP_TYPESAFE_CONVERSION ) + ShaderEXT & operator=( VkShaderEXT shaderEXT ) VULKAN_HPP_NOEXCEPT + { + m_shaderEXT = shaderEXT; + return *this; + } +#endif + + ShaderEXT & operator=( std::nullptr_t ) VULKAN_HPP_NOEXCEPT + { + m_shaderEXT = {}; + return *this; + } + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( ShaderEXT const & ) const = default; +#else + bool operator==( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return m_shaderEXT == rhs.m_shaderEXT; + } + + bool operator!=( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return m_shaderEXT != rhs.m_shaderEXT; + } + + bool operator<( ShaderEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return m_shaderEXT < rhs.m_shaderEXT; + } +#endif + + VULKAN_HPP_TYPESAFE_EXPLICIT operator VkShaderEXT() const VULKAN_HPP_NOEXCEPT + { + return m_shaderEXT; + } + + explicit operator bool() const VULKAN_HPP_NOEXCEPT + { + return m_shaderEXT != VK_NULL_HANDLE; + } + + bool operator!() const VULKAN_HPP_NOEXCEPT + { + return m_shaderEXT == VK_NULL_HANDLE; + } + + private: + VkShaderEXT m_shaderEXT = {}; + }; + + template <> + struct CppType + { + using Type = VULKAN_HPP_NAMESPACE::ShaderEXT; + }; + + template <> + struct isVulkanHandleType + { + static VULKAN_HPP_CONST_OR_CONSTEXPR bool value = true; + }; + class Image { public: @@ -5978,6 +6079,20 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; #endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_EXT_shader_object === + + template + void bindShadersEXT( uint32_t stageCount, + const VULKAN_HPP_NAMESPACE::ShaderStageFlagBits * pStages, + const VULKAN_HPP_NAMESPACE::ShaderEXT * pShaders, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & stages, + VULKAN_HPP_NAMESPACE::ArrayProxy const & shaders, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT_WHEN_NO_EXCEPTIONS; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + operator VkCommandBuffer() const VULKAN_HPP_NOEXCEPT { return m_commandBuffer; @@ -12476,6 +12591,97 @@ namespace VULKAN_HPP_NAMESPACE Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; #endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + //=== VK_EXT_shader_object === + + template + VULKAN_HPP_NODISCARD Result createShadersEXT( uint32_t createInfoCount, + const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT * pCreateInfos, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + VULKAN_HPP_NAMESPACE::ShaderEXT * pShaders, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B0 = ShaderEXTAllocator, + typename std::enable_if::value, int>::type = 0> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + Optional allocator, + ShaderEXTAllocator & shaderEXTAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + template + VULKAN_HPP_NODISCARD typename ResultValueType::type + createShaderEXT( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & createInfo, + Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +# ifndef VULKAN_HPP_NO_SMART_HANDLE + template >> + VULKAN_HPP_NODISCARD typename ResultValueType, ShaderEXTAllocator>>::type + createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + Optional allocator VULKAN_HPP_DEFAULT_ARGUMENT_NULLPTR_ASSIGNMENT, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + template >, + typename B0 = ShaderEXTAllocator, + typename std::enable_if>::value, int>::type = 0> + VULKAN_HPP_NODISCARD typename ResultValueType, ShaderEXTAllocator>>::type + createShadersEXTUnique( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + Optional allocator, + ShaderEXTAllocator & shaderEXTAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + template + VULKAN_HPP_NODISCARD typename ResultValueType>::type + createShaderEXTUnique( const VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT & 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 */ + + template + void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroyShaderEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, + 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 */ + + template + void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT shader, + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * pAllocator, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template + void destroy( VULKAN_HPP_NAMESPACE::ShaderEXT shader, + 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 */ + + template + VULKAN_HPP_NODISCARD Result getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, + size_t * pDataSize, + void * pData, + Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const VULKAN_HPP_NOEXCEPT; +#ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE + template , typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> + VULKAN_HPP_NODISCARD typename ResultValueType>::type + getShaderBinaryDataEXT( VULKAN_HPP_NAMESPACE::ShaderEXT shader, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; + template , + typename Dispatch = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE, + typename B1 = Uint8_tAllocator, + typename std::enable_if::value, int>::type = 0> + VULKAN_HPP_NODISCARD typename ResultValueType>::type getShaderBinaryDataEXT( + VULKAN_HPP_NAMESPACE::ShaderEXT shader, Uint8_tAllocator & uint8_tAllocator, Dispatch const & d VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) const; +#endif /* VULKAN_HPP_DISABLE_ENHANCED_MODE */ + //=== VK_QCOM_tile_properties === template diff --git a/include/vulkan/vulkan_hash.hpp b/include/vulkan/vulkan_hash.hpp index 031883f..86eeecf 100644 --- a/include/vulkan/vulkan_hash.hpp +++ b/include/vulkan/vulkan_hash.hpp @@ -492,6 +492,17 @@ namespace std } }; + //=== VK_EXT_shader_object === + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderEXT const & shaderEXT ) const VULKAN_HPP_NOEXCEPT + { + return std::hash{}( static_cast( shaderEXT ) ); + } + }; + #if 14 <= VULKAN_HPP_CPP_VERSION //====================================== //=== HASH structures for structures === @@ -10074,6 +10085,38 @@ namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT const & physicalDeviceShaderObjectFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectFeaturesEXT.shaderObject ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT const & physicalDeviceShaderObjectPropertiesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.pNext ); + for ( size_t i = 0; i < VK_UUID_SIZE; ++i ) + { + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryUUID[i] ); + } + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderObjectPropertiesEXT.shaderBinaryVersion ); + return seed; + } + }; + template <> struct hash { @@ -10145,6 +10188,38 @@ namespace std } }; + template <> + struct hash + { + std::size_t + operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT const & physicalDeviceShaderTileImageFeaturesEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageColorReadAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageDepthReadAccess ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImageFeaturesEXT.shaderTileImageStencilReadAccess ); + return seed; + } + }; + + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT const & physicalDeviceShaderTileImagePropertiesEXT ) const + VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageCoherentReadAccelerated ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadSampleFromPixelRateInvocation ); + VULKAN_HPP_HASH_COMBINE( seed, physicalDeviceShaderTileImagePropertiesEXT.shaderTileImageReadFromHelperInvocation ); + return seed; + } + }; + template <> struct hash { @@ -12680,6 +12755,33 @@ namespace std } }; + template <> + struct hash + { + std::size_t operator()( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & shaderCreateInfoEXT ) const VULKAN_HPP_NOEXCEPT + { + std::size_t seed = 0; + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.sType ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pNext ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.flags ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.stage ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.nextStage ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeType ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.codeSize ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pCode ); + for ( const char * p = shaderCreateInfoEXT.pName; *p != '\0'; ++p ) + { + VULKAN_HPP_HASH_COMBINE( seed, *p ); + } + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.setLayoutCount ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSetLayouts ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pushConstantRangeCount ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pPushConstantRanges ); + VULKAN_HPP_HASH_COMBINE( seed, shaderCreateInfoEXT.pSpecializationInfo ); + return seed; + } + }; + template <> struct hash { diff --git a/include/vulkan/vulkan_raii.hpp b/include/vulkan/vulkan_raii.hpp index 5f2e739..9d96b6e 100644 --- a/include/vulkan/vulkan_raii.hpp +++ b/include/vulkan/vulkan_raii.hpp @@ -1593,6 +1593,12 @@ namespace VULKAN_HPP_NAMESPACE vkBindOpticalFlowSessionImageNV = PFN_vkBindOpticalFlowSessionImageNV( vkGetDeviceProcAddr( device, "vkBindOpticalFlowSessionImageNV" ) ); vkCmdOpticalFlowExecuteNV = PFN_vkCmdOpticalFlowExecuteNV( vkGetDeviceProcAddr( device, "vkCmdOpticalFlowExecuteNV" ) ); + //=== VK_EXT_shader_object === + vkCreateShadersEXT = PFN_vkCreateShadersEXT( vkGetDeviceProcAddr( device, "vkCreateShadersEXT" ) ); + vkDestroyShaderEXT = PFN_vkDestroyShaderEXT( vkGetDeviceProcAddr( device, "vkDestroyShaderEXT" ) ); + vkGetShaderBinaryDataEXT = PFN_vkGetShaderBinaryDataEXT( vkGetDeviceProcAddr( device, "vkGetShaderBinaryDataEXT" ) ); + vkCmdBindShadersEXT = PFN_vkCmdBindShadersEXT( vkGetDeviceProcAddr( device, "vkCmdBindShadersEXT" ) ); + //=== VK_QCOM_tile_properties === vkGetFramebufferTilePropertiesQCOM = PFN_vkGetFramebufferTilePropertiesQCOM( vkGetDeviceProcAddr( device, "vkGetFramebufferTilePropertiesQCOM" ) ); vkGetDynamicRenderingTilePropertiesQCOM = @@ -2384,6 +2390,12 @@ namespace VULKAN_HPP_NAMESPACE PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV = 0; PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV = 0; + //=== VK_EXT_shader_object === + PFN_vkCreateShadersEXT vkCreateShadersEXT = 0; + PFN_vkDestroyShaderEXT vkDestroyShaderEXT = 0; + PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT = 0; + PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT = 0; + //=== VK_QCOM_tile_properties === PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM = 0; PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM = 0; @@ -2480,6 +2492,9 @@ namespace VULKAN_HPP_NAMESPACE //=== VK_NV_optical_flow === class OpticalFlowSessionNV; + //=== VK_EXT_shader_object === + class ShaderEXT; + //==================== //=== RAII HANDLES === //==================== @@ -4128,6 +4143,16 @@ namespace VULKAN_HPP_NAMESPACE createOpticalFlowSessionNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionCreateInfoNV const & createInfo, VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + //=== VK_EXT_shader_object === + + VULKAN_HPP_NODISCARD std::vector + createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + + VULKAN_HPP_NODISCARD VULKAN_HPP_RAII_NAMESPACE::ShaderEXT + createShaderEXT( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) const; + //=== VK_QCOM_tile_properties === VULKAN_HPP_NODISCARD VULKAN_HPP_NAMESPACE::TilePropertiesQCOM @@ -5855,6 +5880,11 @@ namespace VULKAN_HPP_NAMESPACE void opticalFlowExecuteNV( VULKAN_HPP_NAMESPACE::OpticalFlowSessionNV session, const VULKAN_HPP_NAMESPACE::OpticalFlowExecuteInfoNV & executeInfo ) const VULKAN_HPP_NOEXCEPT; + //=== VK_EXT_shader_object === + + void bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & stages, + VULKAN_HPP_NAMESPACE::ArrayProxy const & shaders ) const; + private: VULKAN_HPP_NAMESPACE::Device m_device = {}; VULKAN_HPP_NAMESPACE::CommandPool m_commandPool = {}; @@ -10142,6 +10172,169 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; }; + class ShaderEXT + { + public: + using CType = VkShaderEXT; + + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::ObjectType objectType = VULKAN_HPP_NAMESPACE::ObjectType::eShaderEXT; + static VULKAN_HPP_CONST_OR_CONSTEXPR VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT debugReportObjectType = + VULKAN_HPP_NAMESPACE::DebugReportObjectTypeEXT::eUnknown; + + public: + ShaderEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, + VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) + : m_device( *device ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + m_constructorSuccessCode = + static_cast( getDispatcher()->vkCreateShadersEXT( static_cast( *device ), + 1, + reinterpret_cast( &createInfo ), + reinterpret_cast( m_allocator ), + reinterpret_cast( &m_shader ) ) ); + if ( m_constructorSuccessCode != VULKAN_HPP_NAMESPACE::Result::eSuccess ) + { + throwResultException( m_constructorSuccessCode, "vkCreateShadersEXT" ); + } + } + + ShaderEXT( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, + VkShaderEXT shader, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) + : m_device( *device ) + , m_shader( shader ) + , m_allocator( static_cast( allocator ) ) + , m_dispatcher( device.getDispatcher() ) + { + } + + ShaderEXT( std::nullptr_t ) {} + + ~ShaderEXT() + { + clear(); + } + + ShaderEXT() = delete; + ShaderEXT( ShaderEXT const & ) = delete; + ShaderEXT( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT + : m_device( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ) ) + , m_shader( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shader, {} ) ) + , m_allocator( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ) ) + , m_dispatcher( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ) ) + { + } + ShaderEXT & operator=( ShaderEXT const & ) = delete; + ShaderEXT & operator =( ShaderEXT && rhs ) VULKAN_HPP_NOEXCEPT + { + if ( this != &rhs ) + { + clear(); + m_device = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_device, {} ); + m_shader = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_shader, {} ); + m_allocator = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_allocator, {} ); + m_dispatcher = VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( rhs.m_dispatcher, nullptr ); + } + return *this; + } + + VULKAN_HPP_NAMESPACE::ShaderEXT const & operator*() const VULKAN_HPP_NOEXCEPT + { + return m_shader; + } + + void clear() VULKAN_HPP_NOEXCEPT + { + if ( m_shader ) + { + getDispatcher()->vkDestroyShaderEXT( + static_cast( m_device ), static_cast( m_shader ), reinterpret_cast( m_allocator ) ); + } + m_device = nullptr; + m_shader = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + } + + VULKAN_HPP_NAMESPACE::ShaderEXT release() + { + m_device = nullptr; + m_allocator = nullptr; + m_dispatcher = nullptr; + return VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::exchange( m_shader, nullptr ); + } + + VULKAN_HPP_NAMESPACE::Device getDevice() const + { + return m_device; + } + + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::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::ShaderEXT & rhs ) VULKAN_HPP_NOEXCEPT + { + std::swap( m_device, rhs.m_device ); + std::swap( m_shader, rhs.m_shader ); + std::swap( m_allocator, rhs.m_allocator ); + std::swap( m_dispatcher, rhs.m_dispatcher ); + } + + //=== VK_EXT_shader_object === + + VULKAN_HPP_NODISCARD std::vector getBinaryData() const; + + private: + VULKAN_HPP_NAMESPACE::Device m_device = {}; + VULKAN_HPP_NAMESPACE::ShaderEXT m_shader = {}; + const VULKAN_HPP_NAMESPACE::AllocationCallbacks * m_allocator = {}; + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * m_dispatcher = nullptr; + }; + + class ShaderEXTs : public std::vector + { + public: + ShaderEXTs( VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::Device const & device, + VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NAMESPACE::Optional allocator = nullptr ) + { + VULKAN_HPP_NAMESPACE::VULKAN_HPP_RAII_NAMESPACE::DeviceDispatcher const * dispatcher = device.getDispatcher(); + std::vector shaders( createInfos.size() ); + VULKAN_HPP_NAMESPACE::Result result = static_cast( dispatcher->vkCreateShadersEXT( + static_cast( *device ), + createInfos.size(), + reinterpret_cast( createInfos.data() ), + reinterpret_cast( static_cast( allocator ) ), + shaders.data() ) ); + if ( result == VULKAN_HPP_NAMESPACE::Result::eSuccess ) + { + this->reserve( createInfos.size() ); + for ( auto const & shaderEXT : shaders ) + { + this->emplace_back( device, shaderEXT, allocator ); + } + } + else + { + throwResultException( result, "vkCreateShadersEXT" ); + } + } + + ShaderEXTs( std::nullptr_t ) {} + + ShaderEXTs() = delete; + ShaderEXTs( ShaderEXTs const & ) = delete; + ShaderEXTs( ShaderEXTs && rhs ) = default; + ShaderEXTs & operator=( ShaderEXTs const & ) = delete; + ShaderEXTs & operator=( ShaderEXTs && rhs ) = default; + }; + class ShaderModule { public: @@ -13453,14 +13646,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setCullMode( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullMode && "Function requires or " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullMode && + "Function requires or or " ); getDispatcher()->vkCmdSetCullMode( static_cast( m_commandBuffer ), static_cast( cullMode ) ); } VULKAN_HPP_INLINE void CommandBuffer::setFrontFace( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFace && "Function requires or " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFace && + "Function requires or or " ); getDispatcher()->vkCmdSetFrontFace( static_cast( m_commandBuffer ), static_cast( frontFace ) ); } @@ -13468,7 +13663,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopology( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveTopology && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetPrimitiveTopology( static_cast( m_commandBuffer ), static_cast( primitiveTopology ) ); } @@ -13477,7 +13672,7 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer::setViewportWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWithCount && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetViewportWithCount( static_cast( m_commandBuffer ), viewports.size(), reinterpret_cast( viewports.data() ) ); @@ -13487,7 +13682,7 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer::setScissorWithCount( VULKAN_HPP_NAMESPACE::ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissorWithCount && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetScissorWithCount( static_cast( m_commandBuffer ), scissors.size(), reinterpret_cast( scissors.data() ) ); @@ -13500,7 +13695,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayProxy const & strides ) const { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers2 && - "Function requires or " ); + "Function requires or or " ); if ( buffers.size() != offsets.size() ) { throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2: buffers.size() != offsets.size()" ); @@ -13526,7 +13721,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthTestEnable && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetDepthTestEnable( static_cast( m_commandBuffer ), static_cast( depthTestEnable ) ); } @@ -13534,7 +13729,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnable( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthWriteEnable && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetDepthWriteEnable( static_cast( m_commandBuffer ), static_cast( depthWriteEnable ) ); } @@ -13542,7 +13737,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOp( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthCompareOp && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetDepthCompareOp( static_cast( m_commandBuffer ), static_cast( depthCompareOp ) ); } @@ -13550,7 +13745,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBoundsTestEnable && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetDepthBoundsTestEnable( static_cast( m_commandBuffer ), static_cast( depthBoundsTestEnable ) ); } @@ -13558,7 +13753,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnable( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilTestEnable && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetStencilTestEnable( static_cast( m_commandBuffer ), static_cast( stencilTestEnable ) ); } @@ -13569,7 +13764,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::StencilOp depthFailOp, VULKAN_HPP_NAMESPACE::CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOp && "Function requires or " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOp && + "Function requires or or " ); getDispatcher()->vkCmdSetStencilOp( static_cast( m_commandBuffer ), static_cast( faceMask ), @@ -13582,7 +13778,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnable( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizerDiscardEnable && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetRasterizerDiscardEnable( static_cast( m_commandBuffer ), static_cast( rasterizerDiscardEnable ) ); } @@ -13590,7 +13786,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnable( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBiasEnable && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetDepthBiasEnable( static_cast( m_commandBuffer ), static_cast( depthBiasEnable ) ); } @@ -13598,7 +13794,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnable( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveRestartEnable && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetPrimitiveRestartEnable( static_cast( m_commandBuffer ), static_cast( primitiveRestartEnable ) ); } @@ -17634,7 +17830,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setCullModeEXT( VULKAN_HPP_NAMESPACE::CullModeFlags cullMode ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCullModeEXT && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetCullModeEXT( static_cast( m_commandBuffer ), static_cast( cullMode ) ); } @@ -17642,7 +17838,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setFrontFaceEXT( VULKAN_HPP_NAMESPACE::FrontFace frontFace ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetFrontFaceEXT && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetFrontFaceEXT( static_cast( m_commandBuffer ), static_cast( frontFace ) ); } @@ -17650,7 +17846,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveTopologyEXT( VULKAN_HPP_NAMESPACE::PrimitiveTopology primitiveTopology ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveTopologyEXT && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetPrimitiveTopologyEXT( static_cast( m_commandBuffer ), static_cast( primitiveTopology ) ); } @@ -17659,7 +17855,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayProxy const & viewports ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWithCountEXT && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetViewportWithCountEXT( static_cast( m_commandBuffer ), viewports.size(), reinterpret_cast( viewports.data() ) ); @@ -17669,7 +17865,7 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer::setScissorWithCountEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & scissors ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetScissorWithCountEXT && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetScissorWithCountEXT( static_cast( m_commandBuffer ), scissors.size(), reinterpret_cast( scissors.data() ) ); @@ -17683,7 +17879,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayProxy const & strides ) const { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindVertexBuffers2EXT && - "Function requires or " ); + "Function requires or or " ); if ( buffers.size() != offsets.size() ) { throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindVertexBuffers2EXT: buffers.size() != offsets.size()" ); @@ -17709,7 +17905,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setDepthTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthTestEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthTestEnableEXT && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetDepthTestEnableEXT( static_cast( m_commandBuffer ), static_cast( depthTestEnable ) ); } @@ -17717,7 +17913,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setDepthWriteEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthWriteEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthWriteEnableEXT && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetDepthWriteEnableEXT( static_cast( m_commandBuffer ), static_cast( depthWriteEnable ) ); } @@ -17725,7 +17921,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setDepthCompareOpEXT( VULKAN_HPP_NAMESPACE::CompareOp depthCompareOp ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthCompareOpEXT && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetDepthCompareOpEXT( static_cast( m_commandBuffer ), static_cast( depthCompareOp ) ); } @@ -17733,7 +17929,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setDepthBoundsTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBoundsTestEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetDepthBoundsTestEnableEXT( static_cast( m_commandBuffer ), static_cast( depthBoundsTestEnable ) ); } @@ -17741,7 +17937,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setStencilTestEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stencilTestEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilTestEnableEXT && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetStencilTestEnableEXT( static_cast( m_commandBuffer ), static_cast( stencilTestEnable ) ); } @@ -17753,7 +17949,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::CompareOp compareOp ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetStencilOpEXT && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetStencilOpEXT( static_cast( m_commandBuffer ), static_cast( faceMask ), @@ -18572,7 +18768,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayProxy const & vertexAttributeDescriptions ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetVertexInputEXT && "Function requires " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetVertexInputEXT && + "Function requires or " ); getDispatcher()->vkCmdSetVertexInputEXT( static_cast( m_commandBuffer ), vertexBindingDescriptions.size(), @@ -18767,15 +18964,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setPatchControlPointsEXT( uint32_t patchControlPoints ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPatchControlPointsEXT && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetPatchControlPointsEXT( static_cast( m_commandBuffer ), patchControlPoints ); } VULKAN_HPP_INLINE void CommandBuffer::setRasterizerDiscardEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 rasterizerDiscardEnable ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT && - "Function requires or " ); + VULKAN_HPP_ASSERT( + getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT && + "Function requires or or " ); getDispatcher()->vkCmdSetRasterizerDiscardEnableEXT( static_cast( m_commandBuffer ), static_cast( rasterizerDiscardEnable ) ); } @@ -18783,22 +18981,24 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setDepthBiasEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthBiasEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthBiasEnableEXT && - "Function requires or " ); + "Function requires or or " ); getDispatcher()->vkCmdSetDepthBiasEnableEXT( static_cast( m_commandBuffer ), static_cast( depthBiasEnable ) ); } VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEXT( VULKAN_HPP_NAMESPACE::LogicOp logicOp ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEXT && "Function requires " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEXT && + "Function requires or " ); getDispatcher()->vkCmdSetLogicOpEXT( static_cast( m_commandBuffer ), static_cast( logicOp ) ); } VULKAN_HPP_INLINE void CommandBuffer::setPrimitiveRestartEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 primitiveRestartEnable ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT && - "Function requires or " ); + VULKAN_HPP_ASSERT( + getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT && + "Function requires or or " ); getDispatcher()->vkCmdSetPrimitiveRestartEnableEXT( static_cast( m_commandBuffer ), static_cast( primitiveRestartEnable ) ); } @@ -19286,7 +19486,7 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer::setTessellationDomainOriginEXT( VULKAN_HPP_NAMESPACE::TessellationDomainOrigin domainOrigin ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetTessellationDomainOriginEXT && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetTessellationDomainOriginEXT( static_cast( m_commandBuffer ), static_cast( domainOrigin ) ); @@ -19294,14 +19494,16 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setDepthClampEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClampEnable ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClampEnableEXT && "Function requires " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClampEnableEXT && + "Function requires or " ); getDispatcher()->vkCmdSetDepthClampEnableEXT( static_cast( m_commandBuffer ), static_cast( depthClampEnable ) ); } VULKAN_HPP_INLINE void CommandBuffer::setPolygonModeEXT( VULKAN_HPP_NAMESPACE::PolygonMode polygonMode ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPolygonModeEXT && "Function requires " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetPolygonModeEXT && + "Function requires or " ); getDispatcher()->vkCmdSetPolygonModeEXT( static_cast( m_commandBuffer ), static_cast( polygonMode ) ); } @@ -19309,7 +19511,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setRasterizationSamplesEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits rasterizationSamples ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizationSamplesEXT && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetRasterizationSamplesEXT( static_cast( m_commandBuffer ), static_cast( rasterizationSamples ) ); @@ -19318,7 +19520,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setSampleMaskEXT( VULKAN_HPP_NAMESPACE::SampleCountFlagBits samples, VULKAN_HPP_NAMESPACE::ArrayProxy const & sampleMask ) const { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleMaskEXT && "Function requires " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleMaskEXT && + "Function requires or " ); if ( sampleMask.size() != ( static_cast( samples ) + 31 ) / 32 ) { throw LogicError( VULKAN_HPP_NAMESPACE_STRING @@ -19333,21 +19536,23 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setAlphaToCoverageEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToCoverageEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAlphaToCoverageEnableEXT && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetAlphaToCoverageEnableEXT( static_cast( m_commandBuffer ), static_cast( alphaToCoverageEnable ) ); } VULKAN_HPP_INLINE void CommandBuffer::setAlphaToOneEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 alphaToOneEnable ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAlphaToOneEnableEXT && "Function requires " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetAlphaToOneEnableEXT && + "Function requires or " ); getDispatcher()->vkCmdSetAlphaToOneEnableEXT( static_cast( m_commandBuffer ), static_cast( alphaToOneEnable ) ); } VULKAN_HPP_INLINE void CommandBuffer::setLogicOpEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 logicOpEnable ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEnableEXT && "Function requires " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLogicOpEnableEXT && + "Function requires or " ); getDispatcher()->vkCmdSetLogicOpEnableEXT( static_cast( m_commandBuffer ), static_cast( logicOpEnable ) ); } @@ -19355,7 +19560,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setColorBlendEnableEXT( uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy const & colorBlendEnables ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendEnableEXT && "Function requires " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendEnableEXT && + "Function requires or " ); getDispatcher()->vkCmdSetColorBlendEnableEXT( static_cast( m_commandBuffer ), firstAttachment, @@ -19368,7 +19574,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayProxy const & colorBlendEquations ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendEquationEXT && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetColorBlendEquationEXT( static_cast( m_commandBuffer ), firstAttachment, @@ -19380,7 +19586,8 @@ namespace VULKAN_HPP_NAMESPACE uint32_t firstAttachment, VULKAN_HPP_NAMESPACE::ArrayProxy const & colorWriteMasks ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorWriteMaskEXT && "Function requires " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorWriteMaskEXT && + "Function requires or " ); getDispatcher()->vkCmdSetColorWriteMaskEXT( static_cast( m_commandBuffer ), firstAttachment, @@ -19391,7 +19598,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setRasterizationStreamEXT( uint32_t rasterizationStream ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRasterizationStreamEXT && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetRasterizationStreamEXT( static_cast( m_commandBuffer ), rasterizationStream ); } @@ -19400,7 +19607,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ConservativeRasterizationModeEXT conservativeRasterizationMode ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetConservativeRasterizationModeEXT && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetConservativeRasterizationModeEXT( static_cast( m_commandBuffer ), static_cast( conservativeRasterizationMode ) ); @@ -19409,14 +19616,15 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setExtraPrimitiveOverestimationSizeEXT( float extraPrimitiveOverestimationSize ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetExtraPrimitiveOverestimationSizeEXT && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetExtraPrimitiveOverestimationSizeEXT( static_cast( m_commandBuffer ), extraPrimitiveOverestimationSize ); } VULKAN_HPP_INLINE void CommandBuffer::setDepthClipEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 depthClipEnable ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClipEnableEXT && "Function requires " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClipEnableEXT && + "Function requires or " ); getDispatcher()->vkCmdSetDepthClipEnableEXT( static_cast( m_commandBuffer ), static_cast( depthClipEnable ) ); } @@ -19424,7 +19632,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setSampleLocationsEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 sampleLocationsEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetSampleLocationsEnableEXT && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetSampleLocationsEnableEXT( static_cast( m_commandBuffer ), static_cast( sampleLocationsEnable ) ); } @@ -19434,7 +19642,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_NAMESPACE::ArrayProxy const & colorBlendAdvanced ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetColorBlendAdvancedEXT && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetColorBlendAdvancedEXT( static_cast( m_commandBuffer ), firstAttachment, @@ -19446,7 +19654,7 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer::setProvokingVertexModeEXT( VULKAN_HPP_NAMESPACE::ProvokingVertexModeEXT provokingVertexMode ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetProvokingVertexModeEXT && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetProvokingVertexModeEXT( static_cast( m_commandBuffer ), static_cast( provokingVertexMode ) ); @@ -19456,7 +19664,7 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer::setLineRasterizationModeEXT( VULKAN_HPP_NAMESPACE::LineRasterizationModeEXT lineRasterizationMode ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineRasterizationModeEXT && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetLineRasterizationModeEXT( static_cast( m_commandBuffer ), static_cast( lineRasterizationMode ) ); @@ -19464,7 +19672,8 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setLineStippleEnableEXT( VULKAN_HPP_NAMESPACE::Bool32 stippledLineEnable ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEnableEXT && "Function requires " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetLineStippleEnableEXT && + "Function requires or " ); getDispatcher()->vkCmdSetLineStippleEnableEXT( static_cast( m_commandBuffer ), static_cast( stippledLineEnable ) ); } @@ -19472,7 +19681,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setDepthClipNegativeOneToOneEXT( VULKAN_HPP_NAMESPACE::Bool32 negativeOneToOne ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetDepthClipNegativeOneToOneEXT && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetDepthClipNegativeOneToOneEXT( static_cast( m_commandBuffer ), static_cast( negativeOneToOne ) ); } @@ -19480,7 +19689,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setViewportWScalingEnableNV( VULKAN_HPP_NAMESPACE::Bool32 viewportWScalingEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportWScalingEnableNV && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetViewportWScalingEnableNV( static_cast( m_commandBuffer ), static_cast( viewportWScalingEnable ) ); } @@ -19489,7 +19698,8 @@ namespace VULKAN_HPP_NAMESPACE uint32_t firstViewport, VULKAN_HPP_NAMESPACE::ArrayProxy const & viewportSwizzles ) const VULKAN_HPP_NOEXCEPT { - VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportSwizzleNV && "Function requires " ); + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetViewportSwizzleNV && + "Function requires or " ); getDispatcher()->vkCmdSetViewportSwizzleNV( static_cast( m_commandBuffer ), firstViewport, @@ -19500,7 +19710,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageToColorEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageToColorEnableNV && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetCoverageToColorEnableNV( static_cast( m_commandBuffer ), static_cast( coverageToColorEnable ) ); } @@ -19508,7 +19718,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setCoverageToColorLocationNV( uint32_t coverageToColorLocation ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageToColorLocationNV && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetCoverageToColorLocationNV( static_cast( m_commandBuffer ), coverageToColorLocation ); } @@ -19517,7 +19727,7 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer::setCoverageModulationModeNV( VULKAN_HPP_NAMESPACE::CoverageModulationModeNV coverageModulationMode ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageModulationModeNV && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetCoverageModulationModeNV( static_cast( m_commandBuffer ), static_cast( coverageModulationMode ) ); @@ -19527,7 +19737,7 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer::setCoverageModulationTableEnableNV( VULKAN_HPP_NAMESPACE::Bool32 coverageModulationTableEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageModulationTableEnableNV && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetCoverageModulationTableEnableNV( static_cast( m_commandBuffer ), static_cast( coverageModulationTableEnable ) ); @@ -19537,7 +19747,7 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer::setCoverageModulationTableNV( VULKAN_HPP_NAMESPACE::ArrayProxy const & coverageModulationTable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageModulationTableNV && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetCoverageModulationTableNV( static_cast( m_commandBuffer ), coverageModulationTable.size(), coverageModulationTable.data() ); @@ -19546,7 +19756,7 @@ namespace VULKAN_HPP_NAMESPACE VULKAN_HPP_INLINE void CommandBuffer::setShadingRateImageEnableNV( VULKAN_HPP_NAMESPACE::Bool32 shadingRateImageEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetShadingRateImageEnableNV && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetShadingRateImageEnableNV( static_cast( m_commandBuffer ), static_cast( shadingRateImageEnable ) ); } @@ -19555,7 +19765,7 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer::setRepresentativeFragmentTestEnableNV( VULKAN_HPP_NAMESPACE::Bool32 representativeFragmentTestEnable ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetRepresentativeFragmentTestEnableNV && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetRepresentativeFragmentTestEnableNV( static_cast( m_commandBuffer ), static_cast( representativeFragmentTestEnable ) ); @@ -19565,7 +19775,7 @@ namespace VULKAN_HPP_NAMESPACE CommandBuffer::setCoverageReductionModeNV( VULKAN_HPP_NAMESPACE::CoverageReductionModeNV coverageReductionMode ) const VULKAN_HPP_NOEXCEPT { VULKAN_HPP_ASSERT( getDispatcher()->vkCmdSetCoverageReductionModeNV && - "Function requires " ); + "Function requires or " ); getDispatcher()->vkCmdSetCoverageReductionModeNV( static_cast( m_commandBuffer ), static_cast( coverageReductionMode ) ); @@ -19667,6 +19877,63 @@ namespace VULKAN_HPP_NAMESPACE reinterpret_cast( &executeInfo ) ); } + //=== VK_EXT_shader_object === + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector + Device::createShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & createInfos, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::ShaderEXTs( *this, createInfos, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE VULKAN_HPP_RAII_NAMESPACE::ShaderEXT + Device::createShaderEXT( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT const & createInfo, + VULKAN_HPP_NAMESPACE::Optional allocator ) const + { + return VULKAN_HPP_RAII_NAMESPACE::ShaderEXT( *this, createInfo, allocator ); + } + + VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector ShaderEXT::getBinaryData() const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkGetShaderBinaryDataEXT && "Function requires " ); + + std::vector data; + size_t dataSize; + VkResult result; + do + { + result = getDispatcher()->vkGetShaderBinaryDataEXT( static_cast( m_device ), static_cast( m_shader ), &dataSize, nullptr ); + if ( ( result == VK_SUCCESS ) && dataSize ) + { + data.resize( dataSize ); + result = getDispatcher()->vkGetShaderBinaryDataEXT( + static_cast( m_device ), static_cast( m_shader ), &dataSize, reinterpret_cast( data.data() ) ); + } + } while ( result == VK_INCOMPLETE ); + resultCheck( static_cast( result ), VULKAN_HPP_NAMESPACE_STRING "::ShaderEXT::getBinaryData" ); + VULKAN_HPP_ASSERT( dataSize <= data.size() ); + if ( dataSize < data.size() ) + { + data.resize( dataSize ); + } + return data; + } + + VULKAN_HPP_INLINE void CommandBuffer::bindShadersEXT( VULKAN_HPP_NAMESPACE::ArrayProxy const & stages, + VULKAN_HPP_NAMESPACE::ArrayProxy const & shaders ) const + { + VULKAN_HPP_ASSERT( getDispatcher()->vkCmdBindShadersEXT && "Function requires " ); + if ( stages.size() != shaders.size() ) + { + throw LogicError( VULKAN_HPP_NAMESPACE_STRING "::CommandBuffer::bindShadersEXT: stages.size() != shaders.size()" ); + } + + getDispatcher()->vkCmdBindShadersEXT( static_cast( m_commandBuffer ), + stages.size(), + reinterpret_cast( stages.data() ), + reinterpret_cast( shaders.data() ) ); + } + //=== VK_QCOM_tile_properties === VULKAN_HPP_NODISCARD VULKAN_HPP_INLINE std::vector Framebuffer::getTilePropertiesQCOM() const diff --git a/include/vulkan/vulkan_static_assertions.hpp b/include/vulkan/vulkan_static_assertions.hpp index cf4595a..c3ea36c 100644 --- a/include/vulkan/vulkan_static_assertions.hpp +++ b/include/vulkan/vulkan_static_assertions.hpp @@ -5780,6 +5780,22 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDeviceImage2DViewOf3DFeaturesEXT is not nothrow_move_constructible!" ); +//=== VK_EXT_shader_tile_image === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImageFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderTileImageFeaturesEXT ), + "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, + "PhysicalDeviceShaderTileImageFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderTileImagePropertiesEXT ) == sizeof( VkPhysicalDeviceShaderTileImagePropertiesEXT ), + "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, + "PhysicalDeviceShaderTileImagePropertiesEXT is not nothrow_move_constructible!" ); + //=== VK_EXT_opacity_micromap === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::MicromapBuildInfoEXT ) == sizeof( VkMicromapBuildInfoEXT ), "struct and wrapper have different size!" ); @@ -6321,6 +6337,30 @@ VULKAN_HPP_STATIC_ASSERT( std::is_standard_layout::value, "PhysicalDevicePipelineProtectedAccessFeaturesEXT is not nothrow_move_constructible!" ); +//=== VK_EXT_shader_object === + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderEXT ) == sizeof( VkShaderEXT ), "handle and wrapper have different size!" ); +VULKAN_HPP_STATIC_ASSERT( std::is_nothrow_move_constructible::value, "ShaderEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectFeaturesEXT ) == sizeof( VkPhysicalDeviceShaderObjectFeaturesEXT ), + "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, + "PhysicalDeviceShaderObjectFeaturesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceShaderObjectPropertiesEXT ) == sizeof( VkPhysicalDeviceShaderObjectPropertiesEXT ), + "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, + "PhysicalDeviceShaderObjectPropertiesEXT is not nothrow_move_constructible!" ); + +VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::ShaderCreateInfoEXT ) == sizeof( VkShaderCreateInfoEXT ), "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, + "ShaderCreateInfoEXT is not nothrow_move_constructible!" ); + //=== VK_QCOM_tile_properties === VULKAN_HPP_STATIC_ASSERT( sizeof( VULKAN_HPP_NAMESPACE::PhysicalDeviceTilePropertiesFeaturesQCOM ) == sizeof( VkPhysicalDeviceTilePropertiesFeaturesQCOM ), diff --git a/include/vulkan/vulkan_structs.hpp b/include/vulkan/vulkan_structs.hpp index a6828d0..1f157dc 100644 --- a/include/vulkan/vulkan_structs.hpp +++ b/include/vulkan/vulkan_structs.hpp @@ -73573,6 +73573,190 @@ namespace VULKAN_HPP_NAMESPACE using Type = PhysicalDeviceShaderModuleIdentifierPropertiesEXT; }; + struct PhysicalDeviceShaderObjectFeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderObjectFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderObjectFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderObjectFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 shaderObject_ = {}, void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , shaderObject( shaderObject_ ) + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderObjectFeaturesEXT( PhysicalDeviceShaderObjectFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderObjectFeaturesEXT( VkPhysicalDeviceShaderObjectFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderObjectFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderObjectFeaturesEXT & operator=( PhysicalDeviceShaderObjectFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + PhysicalDeviceShaderObjectFeaturesEXT & operator=( VkPhysicalDeviceShaderObjectFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectFeaturesEXT & setShaderObject( VULKAN_HPP_NAMESPACE::Bool32 shaderObject_ ) VULKAN_HPP_NOEXCEPT + { + shaderObject = shaderObject_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkPhysicalDeviceShaderObjectFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderObjectFeaturesEXT &() 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, shaderObject ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderObjectFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderObjectFeaturesEXT 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 ) && ( shaderObject == rhs.shaderObject ); +# endif + } + + bool operator!=( PhysicalDeviceShaderObjectFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderObjectFeaturesEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 shaderObject = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderObjectFeaturesEXT; + }; + + struct PhysicalDeviceShaderObjectPropertiesEXT + { + using NativeType = VkPhysicalDeviceShaderObjectPropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderObjectPropertiesEXT; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectPropertiesEXT( std::array const & shaderBinaryUUID_ = {}, + uint32_t shaderBinaryVersion_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , shaderBinaryUUID( shaderBinaryUUID_ ) + , shaderBinaryVersion( shaderBinaryVersion_ ) + { + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderObjectPropertiesEXT( PhysicalDeviceShaderObjectPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderObjectPropertiesEXT( VkPhysicalDeviceShaderObjectPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderObjectPropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderObjectPropertiesEXT & operator=( PhysicalDeviceShaderObjectPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + PhysicalDeviceShaderObjectPropertiesEXT & operator=( VkPhysicalDeviceShaderObjectPropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderObjectPropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderObjectPropertiesEXT &() VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + +#if defined( VULKAN_HPP_USE_REFLECT ) +# if 14 <= VULKAN_HPP_CPP_VERSION + auto +# else + std:: + tuple const &, uint32_t const &> +# endif + reflect() const VULKAN_HPP_NOEXCEPT + { + return std::tie( sType, pNext, shaderBinaryUUID, shaderBinaryVersion ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderObjectPropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderObjectPropertiesEXT 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 ) && ( shaderBinaryUUID == rhs.shaderBinaryUUID ) && + ( shaderBinaryVersion == rhs.shaderBinaryVersion ); +# endif + } + + bool operator!=( PhysicalDeviceShaderObjectPropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderObjectPropertiesEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::ArrayWrapper1D shaderBinaryUUID = {}; + uint32_t shaderBinaryVersion = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderObjectPropertiesEXT; + }; + struct PhysicalDeviceShaderSMBuiltinsFeaturesNV { using NativeType = VkPhysicalDeviceShaderSMBuiltinsFeaturesNV; @@ -74058,6 +74242,226 @@ namespace VULKAN_HPP_NAMESPACE }; using PhysicalDeviceShaderTerminateInvocationFeaturesKHR = PhysicalDeviceShaderTerminateInvocationFeatures; + struct PhysicalDeviceShaderTileImageFeaturesEXT + { + using NativeType = VkPhysicalDeviceShaderTileImageFeaturesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTileImageFeaturesEXT( VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageColorReadAccess_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageDepthReadAccess_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageStencilReadAccess_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , shaderTileImageColorReadAccess( shaderTileImageColorReadAccess_ ) + , shaderTileImageDepthReadAccess( shaderTileImageDepthReadAccess_ ) + , shaderTileImageStencilReadAccess( shaderTileImageStencilReadAccess_ ) + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTileImageFeaturesEXT( PhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderTileImageFeaturesEXT( VkPhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderTileImageFeaturesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderTileImageFeaturesEXT & operator=( PhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + PhysicalDeviceShaderTileImageFeaturesEXT & operator=( VkPhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT & setPNext( void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT & + setShaderTileImageColorReadAccess( VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageColorReadAccess_ ) VULKAN_HPP_NOEXCEPT + { + shaderTileImageColorReadAccess = shaderTileImageColorReadAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT & + setShaderTileImageDepthReadAccess( VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageDepthReadAccess_ ) VULKAN_HPP_NOEXCEPT + { + shaderTileImageDepthReadAccess = shaderTileImageDepthReadAccess_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 PhysicalDeviceShaderTileImageFeaturesEXT & + setShaderTileImageStencilReadAccess( VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageStencilReadAccess_ ) VULKAN_HPP_NOEXCEPT + { + shaderTileImageStencilReadAccess = shaderTileImageStencilReadAccess_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkPhysicalDeviceShaderTileImageFeaturesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderTileImageFeaturesEXT &() 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, shaderTileImageColorReadAccess, shaderTileImageDepthReadAccess, shaderTileImageStencilReadAccess ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderTileImageFeaturesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderTileImageFeaturesEXT 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 ) && ( shaderTileImageColorReadAccess == rhs.shaderTileImageColorReadAccess ) && + ( shaderTileImageDepthReadAccess == rhs.shaderTileImageDepthReadAccess ) && + ( shaderTileImageStencilReadAccess == rhs.shaderTileImageStencilReadAccess ); +# endif + } + + bool operator!=( PhysicalDeviceShaderTileImageFeaturesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageColorReadAccess = {}; + VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageDepthReadAccess = {}; + VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageStencilReadAccess = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderTileImageFeaturesEXT; + }; + + struct PhysicalDeviceShaderTileImagePropertiesEXT + { + using NativeType = VkPhysicalDeviceShaderTileImagePropertiesEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTileImagePropertiesEXT( VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageCoherentReadAccelerated_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageReadSampleFromPixelRateInvocation_ = {}, + VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageReadFromHelperInvocation_ = {}, + void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , shaderTileImageCoherentReadAccelerated( shaderTileImageCoherentReadAccelerated_ ) + , shaderTileImageReadSampleFromPixelRateInvocation( shaderTileImageReadSampleFromPixelRateInvocation_ ) + , shaderTileImageReadFromHelperInvocation( shaderTileImageReadFromHelperInvocation_ ) + { + } + + VULKAN_HPP_CONSTEXPR PhysicalDeviceShaderTileImagePropertiesEXT( PhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + PhysicalDeviceShaderTileImagePropertiesEXT( VkPhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + : PhysicalDeviceShaderTileImagePropertiesEXT( *reinterpret_cast( &rhs ) ) + { + } + + PhysicalDeviceShaderTileImagePropertiesEXT & operator=( PhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + PhysicalDeviceShaderTileImagePropertiesEXT & operator=( VkPhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + + operator VkPhysicalDeviceShaderTileImagePropertiesEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkPhysicalDeviceShaderTileImagePropertiesEXT &() 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, shaderTileImageCoherentReadAccelerated, shaderTileImageReadSampleFromPixelRateInvocation, shaderTileImageReadFromHelperInvocation ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + auto operator<=>( PhysicalDeviceShaderTileImagePropertiesEXT const & ) const = default; +#else + bool operator==( PhysicalDeviceShaderTileImagePropertiesEXT 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 ) && ( shaderTileImageCoherentReadAccelerated == rhs.shaderTileImageCoherentReadAccelerated ) && + ( shaderTileImageReadSampleFromPixelRateInvocation == rhs.shaderTileImageReadSampleFromPixelRateInvocation ) && + ( shaderTileImageReadFromHelperInvocation == rhs.shaderTileImageReadFromHelperInvocation ); +# endif + } + + bool operator!=( PhysicalDeviceShaderTileImagePropertiesEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } +#endif + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT; + void * pNext = {}; + VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageCoherentReadAccelerated = {}; + VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageReadSampleFromPixelRateInvocation = {}; + VULKAN_HPP_NAMESPACE::Bool32 shaderTileImageReadFromHelperInvocation = {}; + }; + + template <> + struct CppType + { + using Type = PhysicalDeviceShaderTileImagePropertiesEXT; + }; + struct PhysicalDeviceShadingRateImageFeaturesNV { using NativeType = VkPhysicalDeviceShadingRateImageFeaturesNV; @@ -83559,6 +83963,7 @@ namespace VULKAN_HPP_NAMESPACE using Type = PipelineShaderStageRequiredSubgroupSizeCreateInfo; }; using PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo; + using ShaderRequiredSubgroupSizeCreateInfoEXT = PipelineShaderStageRequiredSubgroupSizeCreateInfo; struct PipelineTessellationDomainOriginStateCreateInfo { @@ -94204,6 +94609,321 @@ namespace VULKAN_HPP_NAMESPACE uint32_t data = {}; }; + struct ShaderCreateInfoEXT + { + using NativeType = VkShaderCreateInfoEXT; + + static const bool allowDuplicate = false; + static VULKAN_HPP_CONST_OR_CONSTEXPR StructureType structureType = StructureType::eShaderCreateInfoEXT; + +#if !defined( VULKAN_HPP_NO_STRUCT_CONSTRUCTORS ) + VULKAN_HPP_CONSTEXPR ShaderCreateInfoEXT( VULKAN_HPP_NAMESPACE::ShaderCreateFlagsEXT flags_ = {}, + VULKAN_HPP_NAMESPACE::ShaderStageFlagBits stage_ = VULKAN_HPP_NAMESPACE::ShaderStageFlagBits::eVertex, + VULKAN_HPP_NAMESPACE::ShaderStageFlags nextStage_ = {}, + VULKAN_HPP_NAMESPACE::ShaderCodeTypeEXT codeType_ = VULKAN_HPP_NAMESPACE::ShaderCodeTypeEXT::eBinary, + size_t codeSize_ = {}, + const void * pCode_ = {}, + const char * pName_ = {}, + uint32_t setLayoutCount_ = {}, + const VULKAN_HPP_NAMESPACE::DescriptorSetLayout * pSetLayouts_ = {}, + uint32_t pushConstantRangeCount_ = {}, + const VULKAN_HPP_NAMESPACE::PushConstantRange * pPushConstantRanges_ = {}, + const VULKAN_HPP_NAMESPACE::SpecializationInfo * pSpecializationInfo_ = {}, + const void * pNext_ = nullptr ) VULKAN_HPP_NOEXCEPT + : pNext( pNext_ ) + , flags( flags_ ) + , stage( stage_ ) + , nextStage( nextStage_ ) + , codeType( codeType_ ) + , codeSize( codeSize_ ) + , pCode( pCode_ ) + , pName( pName_ ) + , setLayoutCount( setLayoutCount_ ) + , pSetLayouts( pSetLayouts_ ) + , pushConstantRangeCount( pushConstantRangeCount_ ) + , pPushConstantRanges( pPushConstantRanges_ ) + , pSpecializationInfo( pSpecializationInfo_ ) + { + } + + VULKAN_HPP_CONSTEXPR ShaderCreateInfoEXT( ShaderCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; + + ShaderCreateInfoEXT( VkShaderCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT : ShaderCreateInfoEXT( *reinterpret_cast( &rhs ) ) + { + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + ShaderCreateInfoEXT( VULKAN_HPP_NAMESPACE::ShaderCreateFlagsEXT flags_, + VULKAN_HPP_NAMESPACE::ShaderStageFlagBits stage_, + VULKAN_HPP_NAMESPACE::ShaderStageFlags nextStage_, + VULKAN_HPP_NAMESPACE::ShaderCodeTypeEXT codeType_, + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & code_, + const char * pName_ = {}, + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & setLayouts_ = {}, + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & pushConstantRanges_ = {}, + const VULKAN_HPP_NAMESPACE::SpecializationInfo * pSpecializationInfo_ = {}, + const void * pNext_ = nullptr ) + : pNext( pNext_ ) + , flags( flags_ ) + , stage( stage_ ) + , nextStage( nextStage_ ) + , codeType( codeType_ ) + , codeSize( code_.size() * sizeof( T ) ) + , pCode( code_.data() ) + , pName( pName_ ) + , setLayoutCount( static_cast( setLayouts_.size() ) ) + , pSetLayouts( setLayouts_.data() ) + , pushConstantRangeCount( static_cast( pushConstantRanges_.size() ) ) + , pPushConstantRanges( pushConstantRanges_.data() ) + , pSpecializationInfo( pSpecializationInfo_ ) + { + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + ShaderCreateInfoEXT & operator=( ShaderCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT = default; +#endif /*VULKAN_HPP_NO_STRUCT_CONSTRUCTORS*/ + + ShaderCreateInfoEXT & operator=( VkShaderCreateInfoEXT const & rhs ) VULKAN_HPP_NOEXCEPT + { + *this = *reinterpret_cast( &rhs ); + return *this; + } + +#if !defined( VULKAN_HPP_NO_STRUCT_SETTERS ) + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPNext( const void * pNext_ ) VULKAN_HPP_NOEXCEPT + { + pNext = pNext_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setFlags( VULKAN_HPP_NAMESPACE::ShaderCreateFlagsEXT flags_ ) VULKAN_HPP_NOEXCEPT + { + flags = flags_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setStage( VULKAN_HPP_NAMESPACE::ShaderStageFlagBits stage_ ) VULKAN_HPP_NOEXCEPT + { + stage = stage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setNextStage( VULKAN_HPP_NAMESPACE::ShaderStageFlags nextStage_ ) VULKAN_HPP_NOEXCEPT + { + nextStage = nextStage_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setCodeType( VULKAN_HPP_NAMESPACE::ShaderCodeTypeEXT codeType_ ) VULKAN_HPP_NOEXCEPT + { + codeType = codeType_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setCodeSize( size_t codeSize_ ) VULKAN_HPP_NOEXCEPT + { + codeSize = codeSize_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPCode( const void * pCode_ ) VULKAN_HPP_NOEXCEPT + { + pCode = pCode_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + template + ShaderCreateInfoEXT & setCode( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & code_ ) VULKAN_HPP_NOEXCEPT + { + codeSize = code_.size() * sizeof( T ); + pCode = code_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPName( const char * pName_ ) VULKAN_HPP_NOEXCEPT + { + pName = pName_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setSetLayoutCount( uint32_t setLayoutCount_ ) VULKAN_HPP_NOEXCEPT + { + setLayoutCount = setLayoutCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPSetLayouts( const VULKAN_HPP_NAMESPACE::DescriptorSetLayout * pSetLayouts_ ) VULKAN_HPP_NOEXCEPT + { + pSetLayouts = pSetLayouts_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ShaderCreateInfoEXT & + setSetLayouts( VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & setLayouts_ ) VULKAN_HPP_NOEXCEPT + { + setLayoutCount = static_cast( setLayouts_.size() ); + pSetLayouts = setLayouts_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & setPushConstantRangeCount( uint32_t pushConstantRangeCount_ ) VULKAN_HPP_NOEXCEPT + { + pushConstantRangeCount = pushConstantRangeCount_; + return *this; + } + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & + setPPushConstantRanges( const VULKAN_HPP_NAMESPACE::PushConstantRange * pPushConstantRanges_ ) VULKAN_HPP_NOEXCEPT + { + pPushConstantRanges = pPushConstantRanges_; + return *this; + } + +# if !defined( VULKAN_HPP_DISABLE_ENHANCED_MODE ) + ShaderCreateInfoEXT & setPushConstantRanges( + VULKAN_HPP_NAMESPACE::ArrayProxyNoTemporaries const & pushConstantRanges_ ) VULKAN_HPP_NOEXCEPT + { + pushConstantRangeCount = static_cast( pushConstantRanges_.size() ); + pPushConstantRanges = pushConstantRanges_.data(); + return *this; + } +# endif /*VULKAN_HPP_DISABLE_ENHANCED_MODE*/ + + VULKAN_HPP_CONSTEXPR_14 ShaderCreateInfoEXT & + setPSpecializationInfo( const VULKAN_HPP_NAMESPACE::SpecializationInfo * pSpecializationInfo_ ) VULKAN_HPP_NOEXCEPT + { + pSpecializationInfo = pSpecializationInfo_; + return *this; + } +#endif /*VULKAN_HPP_NO_STRUCT_SETTERS*/ + + operator VkShaderCreateInfoEXT const &() const VULKAN_HPP_NOEXCEPT + { + return *reinterpret_cast( this ); + } + + operator VkShaderCreateInfoEXT &() 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, + stage, + nextStage, + codeType, + codeSize, + pCode, + pName, + setLayoutCount, + pSetLayouts, + pushConstantRangeCount, + pPushConstantRanges, + pSpecializationInfo ); + } +#endif + +#if defined( VULKAN_HPP_HAS_SPACESHIP_OPERATOR ) + std::strong_ordering operator<=>( ShaderCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + if ( auto cmp = sType <=> rhs.sType; cmp != 0 ) + return cmp; + if ( auto cmp = pNext <=> rhs.pNext; cmp != 0 ) + return cmp; + if ( auto cmp = flags <=> rhs.flags; cmp != 0 ) + return cmp; + if ( auto cmp = stage <=> rhs.stage; cmp != 0 ) + return cmp; + if ( auto cmp = nextStage <=> rhs.nextStage; cmp != 0 ) + return cmp; + if ( auto cmp = codeType <=> rhs.codeType; cmp != 0 ) + return cmp; + if ( auto cmp = codeSize <=> rhs.codeSize; cmp != 0 ) + return cmp; + if ( auto cmp = pCode <=> rhs.pCode; cmp != 0 ) + return cmp; + if ( pName != rhs.pName ) + if ( auto cmp = strcmp( pName, rhs.pName ); cmp != 0 ) + return ( cmp < 0 ) ? std::strong_ordering::less : std::strong_ordering::greater; + if ( auto cmp = setLayoutCount <=> rhs.setLayoutCount; cmp != 0 ) + return cmp; + if ( auto cmp = pSetLayouts <=> rhs.pSetLayouts; cmp != 0 ) + return cmp; + if ( auto cmp = pushConstantRangeCount <=> rhs.pushConstantRangeCount; cmp != 0 ) + return cmp; + if ( auto cmp = pPushConstantRanges <=> rhs.pPushConstantRanges; cmp != 0 ) + return cmp; + if ( auto cmp = pSpecializationInfo <=> rhs.pSpecializationInfo; cmp != 0 ) + return cmp; + + return std::strong_ordering::equivalent; + } +#endif + + bool operator==( ShaderCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return ( sType == rhs.sType ) && ( pNext == rhs.pNext ) && ( flags == rhs.flags ) && ( stage == rhs.stage ) && ( nextStage == rhs.nextStage ) && + ( codeType == rhs.codeType ) && ( codeSize == rhs.codeSize ) && ( pCode == rhs.pCode ) && + ( ( pName == rhs.pName ) || ( strcmp( pName, rhs.pName ) == 0 ) ) && ( setLayoutCount == rhs.setLayoutCount ) && + ( pSetLayouts == rhs.pSetLayouts ) && ( pushConstantRangeCount == rhs.pushConstantRangeCount ) && + ( pPushConstantRanges == rhs.pPushConstantRanges ) && ( pSpecializationInfo == rhs.pSpecializationInfo ); + } + + bool operator!=( ShaderCreateInfoEXT const & rhs ) const VULKAN_HPP_NOEXCEPT + { + return !operator==( rhs ); + } + + public: + VULKAN_HPP_NAMESPACE::StructureType sType = StructureType::eShaderCreateInfoEXT; + const void * pNext = {}; + VULKAN_HPP_NAMESPACE::ShaderCreateFlagsEXT flags = {}; + VULKAN_HPP_NAMESPACE::ShaderStageFlagBits stage = VULKAN_HPP_NAMESPACE::ShaderStageFlagBits::eVertex; + VULKAN_HPP_NAMESPACE::ShaderStageFlags nextStage = {}; + VULKAN_HPP_NAMESPACE::ShaderCodeTypeEXT codeType = VULKAN_HPP_NAMESPACE::ShaderCodeTypeEXT::eBinary; + size_t codeSize = {}; + const void * pCode = {}; + const char * pName = {}; + uint32_t setLayoutCount = {}; + const VULKAN_HPP_NAMESPACE::DescriptorSetLayout * pSetLayouts = {}; + uint32_t pushConstantRangeCount = {}; + const VULKAN_HPP_NAMESPACE::PushConstantRange * pPushConstantRanges = {}; + const VULKAN_HPP_NAMESPACE::SpecializationInfo * pSpecializationInfo = {}; + }; + + template <> + struct CppType + { + using Type = ShaderCreateInfoEXT; + }; + struct ShaderModuleCreateInfo { using NativeType = VkShaderModuleCreateInfo; diff --git a/include/vulkan/vulkan_to_string.hpp b/include/vulkan/vulkan_to_string.hpp index 357c91d..832292f 100644 --- a/include/vulkan/vulkan_to_string.hpp +++ b/include/vulkan/vulkan_to_string.hpp @@ -3205,6 +3205,32 @@ namespace VULKAN_HPP_NAMESPACE return "{ " + result.substr( 0, result.size() - 3 ) + " }"; } + //=== VK_EXT_shader_object === + + VULKAN_HPP_INLINE std::string to_string( ShaderCreateFlagsEXT value ) + { + if ( !value ) + return "{}"; + + std::string result; + if ( value & ShaderCreateFlagBitsEXT::eLinkStage ) + result += "LinkStage | "; + if ( value & ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize ) + result += "AllowVaryingSubgroupSize | "; + if ( value & ShaderCreateFlagBitsEXT::eRequireFullSubgroups ) + result += "RequireFullSubgroups | "; + if ( value & ShaderCreateFlagBitsEXT::eNoTaskShader ) + result += "NoTaskShader | "; + if ( value & ShaderCreateFlagBitsEXT::eDispatchBase ) + result += "DispatchBase | "; + if ( value & ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment ) + result += "FragmentShadingRateAttachment | "; + if ( value & ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment ) + result += "FragmentDensityMapAttachment | "; + + return "{ " + result.substr( 0, result.size() - 3 ) + " }"; + } + //======================= //=== ENUMs to_string === //======================= @@ -3276,6 +3302,7 @@ namespace VULKAN_HPP_NAMESPACE case Result::eErrorInvalidVideoStdParametersKHR: return "ErrorInvalidVideoStdParametersKHR"; #endif /*VK_ENABLE_BETA_EXTENSIONS*/ case Result::eErrorCompressionExhaustedEXT: return "ErrorCompressionExhaustedEXT"; + case Result::eErrorIncompatibleShaderBinaryEXT: return "ErrorIncompatibleShaderBinaryEXT"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -4018,6 +4045,8 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::ePhysicalDeviceMultiDrawFeaturesEXT: return "PhysicalDeviceMultiDrawFeaturesEXT"; case StructureType::ePhysicalDeviceMultiDrawPropertiesEXT: return "PhysicalDeviceMultiDrawPropertiesEXT"; case StructureType::ePhysicalDeviceImage2DViewOf3DFeaturesEXT: return "PhysicalDeviceImage2DViewOf3DFeaturesEXT"; + case StructureType::ePhysicalDeviceShaderTileImageFeaturesEXT: return "PhysicalDeviceShaderTileImageFeaturesEXT"; + case StructureType::ePhysicalDeviceShaderTileImagePropertiesEXT: return "PhysicalDeviceShaderTileImagePropertiesEXT"; case StructureType::eMicromapBuildInfoEXT: return "MicromapBuildInfoEXT"; case StructureType::eMicromapVersionInfoEXT: return "MicromapVersionInfoEXT"; case StructureType::eCopyMicromapInfoEXT: return "CopyMicromapInfoEXT"; @@ -4080,6 +4109,9 @@ namespace VULKAN_HPP_NAMESPACE case StructureType::eOpticalFlowSessionCreatePrivateDataInfoNV: return "OpticalFlowSessionCreatePrivateDataInfoNV"; case StructureType::ePhysicalDeviceLegacyDitheringFeaturesEXT: return "PhysicalDeviceLegacyDitheringFeaturesEXT"; case StructureType::ePhysicalDevicePipelineProtectedAccessFeaturesEXT: return "PhysicalDevicePipelineProtectedAccessFeaturesEXT"; + case StructureType::ePhysicalDeviceShaderObjectFeaturesEXT: return "PhysicalDeviceShaderObjectFeaturesEXT"; + case StructureType::ePhysicalDeviceShaderObjectPropertiesEXT: return "PhysicalDeviceShaderObjectPropertiesEXT"; + case StructureType::eShaderCreateInfoEXT: return "ShaderCreateInfoEXT"; case StructureType::ePhysicalDeviceTilePropertiesFeaturesQCOM: return "PhysicalDeviceTilePropertiesFeaturesQCOM"; case StructureType::eTilePropertiesQCOM: return "TilePropertiesQCOM"; case StructureType::ePhysicalDeviceAmigoProfilingFeaturesSEC: return "PhysicalDeviceAmigoProfilingFeaturesSEC"; @@ -4161,6 +4193,7 @@ namespace VULKAN_HPP_NAMESPACE #endif /*VK_USE_PLATFORM_FUCHSIA*/ case ObjectType::eMicromapEXT: return "MicromapEXT"; case ObjectType::eOpticalFlowSessionNV: return "OpticalFlowSessionNV"; + case ObjectType::eShaderEXT: return "ShaderEXT"; default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; } } @@ -8312,6 +8345,33 @@ namespace VULKAN_HPP_NAMESPACE } } + //=== VK_EXT_shader_object === + + VULKAN_HPP_INLINE std::string to_string( ShaderCreateFlagBitsEXT value ) + { + switch ( value ) + { + case ShaderCreateFlagBitsEXT::eLinkStage: return "LinkStage"; + case ShaderCreateFlagBitsEXT::eAllowVaryingSubgroupSize: return "AllowVaryingSubgroupSize"; + case ShaderCreateFlagBitsEXT::eRequireFullSubgroups: return "RequireFullSubgroups"; + case ShaderCreateFlagBitsEXT::eNoTaskShader: return "NoTaskShader"; + case ShaderCreateFlagBitsEXT::eDispatchBase: return "DispatchBase"; + case ShaderCreateFlagBitsEXT::eFragmentShadingRateAttachment: return "FragmentShadingRateAttachment"; + case ShaderCreateFlagBitsEXT::eFragmentDensityMapAttachment: return "FragmentDensityMapAttachment"; + default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; + } + } + + VULKAN_HPP_INLINE std::string to_string( ShaderCodeTypeEXT value ) + { + switch ( value ) + { + case ShaderCodeTypeEXT::eBinary: return "Binary"; + case ShaderCodeTypeEXT::eSpirv: return "Spirv"; + default: return "invalid ( " + VULKAN_HPP_NAMESPACE::toHexString( static_cast( value ) ) + " )"; + } + } + //=== VK_NV_ray_tracing_invocation_reorder === VULKAN_HPP_INLINE std::string to_string( RayTracingInvocationReorderModeNV value ) diff --git a/registry/genvk.py b/registry/genvk.py index 5242036..67cd8d0 100755 --- a/registry/genvk.py +++ b/registry/genvk.py @@ -364,10 +364,12 @@ def makeGenOpts(args): 'VK_KHR_video_encode_queue', 'VK_EXT_video_encode_h264', 'VK_EXT_video_encode_h265', + 'VK_NV_displacement_micromap', ] betaSuppressExtensions = [ - 'VK_KHR_video_queue' + 'VK_KHR_video_queue', + 'VK_EXT_opacity_micromap', ] platforms = [ diff --git a/registry/validusage.json b/registry/validusage.json index 59c79ea..0bbe49a 100644 --- a/registry/validusage.json +++ b/registry/validusage.json @@ -1,9 +1,9 @@ { "version info": { "schema version": 2, - "api version": "1.3.245", - "comment": "from git branch: github-main commit: 729dda35a16d57611636d6684a1fcb27f7e0a722", - "date": "2023-03-24 11:19:10Z" + "api version": "1.3.246", + "comment": "from git branch: github-main commit: ce847fd14cc3a81751329352ce505501c46ce35e", + "date": "2023-03-31 09:55:10Z" }, "validation": { "vkGetInstanceProcAddr": { @@ -288,7 +288,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, VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceCopyMemoryIndirectPropertiesNV, VkPhysicalDeviceCustomBorderColorPropertiesEXT, VkPhysicalDeviceDepthStencilResolveProperties, VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, VkPhysicalDeviceDescriptorBufferPropertiesEXT, VkPhysicalDeviceDescriptorIndexingProperties, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDisplacementMicromapPropertiesNV, VkPhysicalDeviceDriverProperties, VkPhysicalDeviceDrmPropertiesEXT, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsProperties, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT, VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR, VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV, VkPhysicalDeviceFragmentShadingRatePropertiesKHR, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceImageProcessingPropertiesQCOM, VkPhysicalDeviceInlineUniformBlockProperties, VkPhysicalDeviceLineRasterizationPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMaintenance4Properties, VkPhysicalDeviceMemoryDecompressionPropertiesNV, VkPhysicalDeviceMeshShaderPropertiesEXT, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiDrawPropertiesEXT, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDeviceOpacityMicromapPropertiesEXT, VkPhysicalDeviceOpticalFlowPropertiesNV, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePerformanceQueryPropertiesKHR, VkPhysicalDevicePipelineRobustnessPropertiesEXT, VkPhysicalDevicePointClippingProperties, VkPhysicalDevicePortabilitySubsetPropertiesKHR, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDeviceProvokingVertexPropertiesEXT, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV, VkPhysicalDeviceRayTracingPipelinePropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceRobustness2PropertiesEXT, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxProperties, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM, VkPhysicalDeviceShaderCoreProperties2AMD, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderCorePropertiesARM, VkPhysicalDeviceShaderIntegerDotProductProperties, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceSubgroupSizeControlProperties, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI, VkPhysicalDeviceTexelBufferAlignmentProperties, VkPhysicalDeviceTimelineSemaphoreProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT, VkPhysicalDeviceVulkan11Properties, VkPhysicalDeviceVulkan12Properties, or VkPhysicalDeviceVulkan13Properties" + "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, VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceCopyMemoryIndirectPropertiesNV, VkPhysicalDeviceCustomBorderColorPropertiesEXT, VkPhysicalDeviceDepthStencilResolveProperties, VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT, VkPhysicalDeviceDescriptorBufferPropertiesEXT, VkPhysicalDeviceDescriptorIndexingProperties, VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDisplacementMicromapPropertiesNV, VkPhysicalDeviceDriverProperties, VkPhysicalDeviceDrmPropertiesEXT, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsProperties, VkPhysicalDeviceFragmentDensityMap2PropertiesEXT, VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR, VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV, VkPhysicalDeviceFragmentShadingRatePropertiesKHR, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceImageProcessingPropertiesQCOM, VkPhysicalDeviceInlineUniformBlockProperties, VkPhysicalDeviceLineRasterizationPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMaintenance4Properties, VkPhysicalDeviceMemoryDecompressionPropertiesNV, VkPhysicalDeviceMeshShaderPropertiesEXT, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiDrawPropertiesEXT, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDeviceOpacityMicromapPropertiesEXT, VkPhysicalDeviceOpticalFlowPropertiesNV, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePerformanceQueryPropertiesKHR, VkPhysicalDevicePipelineRobustnessPropertiesEXT, VkPhysicalDevicePointClippingProperties, VkPhysicalDevicePortabilitySubsetPropertiesKHR, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDeviceProvokingVertexPropertiesEXT, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV, VkPhysicalDeviceRayTracingPipelinePropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceRobustness2PropertiesEXT, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxProperties, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM, VkPhysicalDeviceShaderCoreProperties2AMD, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderCorePropertiesARM, VkPhysicalDeviceShaderIntegerDotProductProperties, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT, VkPhysicalDeviceShaderObjectPropertiesEXT, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShaderTileImagePropertiesEXT, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceSubgroupSizeControlProperties, VkPhysicalDeviceSubpassShadingPropertiesHUAWEI, VkPhysicalDeviceTexelBufferAlignmentProperties, VkPhysicalDeviceTimelineSemaphoreProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT, VkPhysicalDeviceVulkan11Properties, VkPhysicalDeviceVulkan12Properties, or VkPhysicalDeviceVulkan13Properties" }, { "vuid": "VUID-VkPhysicalDeviceProperties2-sType-unique", @@ -368,6 +368,14 @@ } ] }, + "VkPhysicalDeviceShaderTileImagePropertiesEXT": { + "(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderTileImagePropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT" + } + ] + }, "vkGetPhysicalDeviceQueueFamilyProperties": { "core": [ { @@ -730,7 +738,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, VkDevicePrivateDataCreateInfo, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice4444FormatsFeaturesEXT, VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceAccelerationStructureFeaturesKHR, VkPhysicalDeviceAddressBindingReportFeaturesEXT, VkPhysicalDeviceAmigoProfilingFeaturesSEC, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeatures, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceColorWriteEnableFeaturesEXT, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCopyMemoryIndirectFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceCustomBorderColorFeaturesEXT, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClampZeroOneFeaturesEXT, VkPhysicalDeviceDepthClipControlFeaturesEXT, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorBufferFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, VkPhysicalDeviceDiagnosticsConfigFeaturesNV, VkPhysicalDeviceDisplacementMicromapFeaturesNV, VkPhysicalDeviceDynamicRenderingFeatures, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV, VkPhysicalDeviceFaultFeaturesEXT, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, VkPhysicalDeviceFragmentShadingRateFeaturesKHR, VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT, VkPhysicalDeviceImageCompressionControlFeaturesEXT, VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, VkPhysicalDeviceImageProcessingFeaturesQCOM, VkPhysicalDeviceImageRobustnessFeatures, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT, VkPhysicalDeviceImageViewMinLodFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInheritedViewportScissorFeaturesNV, VkPhysicalDeviceInlineUniformBlockFeatures, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI, VkPhysicalDeviceLegacyDitheringFeaturesEXT, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceLinearColorAttachmentFeaturesNV, VkPhysicalDeviceMaintenance4Features, VkPhysicalDeviceMemoryDecompressionFeaturesNV, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiDrawFeaturesEXT, VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT, VkPhysicalDeviceOpacityMicromapFeaturesEXT, VkPhysicalDeviceOpticalFlowFeaturesNV, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePipelineCreationCacheControlFeatures, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, VkPhysicalDevicePipelinePropertiesFeaturesEXT, VkPhysicalDevicePipelineProtectedAccessFeaturesEXT, VkPhysicalDevicePipelineRobustnessFeaturesEXT, VkPhysicalDevicePortabilitySubsetFeaturesKHR, VkPhysicalDevicePresentBarrierFeaturesNV, VkPhysicalDevicePresentIdFeaturesKHR, VkPhysicalDevicePresentWaitFeaturesKHR, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, VkPhysicalDevicePrivateDataFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceProvokingVertexFeaturesEXT, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, VkPhysicalDeviceRayQueryFeaturesKHR, VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV, VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV, VkPhysicalDeviceRayTracingPipelineFeaturesKHR, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceRobustness2FeaturesEXT, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerDotProductFeatures, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, VkPhysicalDeviceShaderTerminateInvocationFeatures, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeatures, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI, VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT, VkPhysicalDeviceSynchronization2Features, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeatures, VkPhysicalDeviceTilePropertiesFeaturesQCOM, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan12Features, VkPhysicalDeviceVulkan13Features, VkPhysicalDeviceVulkanMemoryModelFeatures, VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, 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, VkDevicePrivateDataCreateInfo, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice4444FormatsFeaturesEXT, VkPhysicalDevice8BitStorageFeatures, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceAccelerationStructureFeaturesKHR, VkPhysicalDeviceAddressBindingReportFeaturesEXT, VkPhysicalDeviceAmigoProfilingFeaturesSEC, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeatures, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceColorWriteEnableFeaturesEXT, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCopyMemoryIndirectFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceCustomBorderColorFeaturesEXT, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClampZeroOneFeaturesEXT, VkPhysicalDeviceDepthClipControlFeaturesEXT, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorBufferFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeatures, VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE, VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV, VkPhysicalDeviceDeviceMemoryReportFeaturesEXT, VkPhysicalDeviceDiagnosticsConfigFeaturesNV, VkPhysicalDeviceDisplacementMicromapFeaturesNV, VkPhysicalDeviceDynamicRenderingFeatures, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT, VkPhysicalDeviceExtendedDynamicStateFeaturesEXT, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV, VkPhysicalDeviceFaultFeaturesEXT, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMap2FeaturesEXT, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV, VkPhysicalDeviceFragmentShadingRateFeaturesKHR, VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT, VkPhysicalDeviceHostQueryResetFeatures, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT, VkPhysicalDeviceImageCompressionControlFeaturesEXT, VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT, VkPhysicalDeviceImageProcessingFeaturesQCOM, VkPhysicalDeviceImageRobustnessFeatures, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT, VkPhysicalDeviceImageViewMinLodFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeatures, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInheritedViewportScissorFeaturesNV, VkPhysicalDeviceInlineUniformBlockFeatures, VkPhysicalDeviceInvocationMaskFeaturesHUAWEI, VkPhysicalDeviceLegacyDitheringFeaturesEXT, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceLinearColorAttachmentFeaturesNV, VkPhysicalDeviceMaintenance4Features, VkPhysicalDeviceMemoryDecompressionFeaturesNV, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiDrawFeaturesEXT, VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM, VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT, VkPhysicalDeviceOpacityMicromapFeaturesEXT, VkPhysicalDeviceOpticalFlowFeaturesNV, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT, VkPhysicalDevicePerformanceQueryFeaturesKHR, VkPhysicalDevicePipelineCreationCacheControlFeatures, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT, VkPhysicalDevicePipelinePropertiesFeaturesEXT, VkPhysicalDevicePipelineProtectedAccessFeaturesEXT, VkPhysicalDevicePipelineRobustnessFeaturesEXT, VkPhysicalDevicePortabilitySubsetFeaturesKHR, VkPhysicalDevicePresentBarrierFeaturesNV, VkPhysicalDevicePresentIdFeaturesKHR, VkPhysicalDevicePresentWaitFeaturesKHR, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT, VkPhysicalDevicePrivateDataFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceProvokingVertexFeaturesEXT, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT, VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT, VkPhysicalDeviceRayQueryFeaturesKHR, VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV, VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR, VkPhysicalDeviceRayTracingMotionBlurFeaturesNV, VkPhysicalDeviceRayTracingPipelineFeaturesKHR, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceRobustness2FeaturesEXT, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeatures, VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT, VkPhysicalDeviceShaderAtomicFloatFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64Features, VkPhysicalDeviceShaderClockFeaturesKHR, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, VkPhysicalDeviceShaderFloat16Int8Features, VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerDotProductFeatures, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT, VkPhysicalDeviceShaderObjectFeaturesEXT, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures, VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, VkPhysicalDeviceShaderTerminateInvocationFeatures, VkPhysicalDeviceShaderTileImageFeaturesEXT, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeatures, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT, VkPhysicalDeviceSubpassShadingFeaturesHUAWEI, VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT, VkPhysicalDeviceSynchronization2Features, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeatures, VkPhysicalDeviceTilePropertiesFeaturesQCOM, VkPhysicalDeviceTimelineSemaphoreFeatures, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeatures, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT, VkPhysicalDeviceVulkan11Features, VkPhysicalDeviceVulkan12Features, VkPhysicalDeviceVulkan13Features, VkPhysicalDeviceVulkanMemoryModelFeatures, VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT, or VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures" }, { "vuid": "VUID-VkDeviceCreateInfo-sType-unique", @@ -4745,7 +4753,17 @@ "text": " If fname:vkCmdPipelineBarrier2 is called inside a render pass instance, and there is more than one view in the current subpass, dependency flags must include VK_DEPENDENCY_VIEW_LOCAL_BIT" } ], - "(VK_VERSION_1_3,VK_KHR_synchronization2)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ + "(VK_VERSION_1_3,VK_KHR_synchronization2)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier2-shaderTileImageColorReadAccess-08718", + "text": " If fname:vkCmdPipelineBarrier2 is called within a render pass instance and none of the shaderTileImageColorReadAccess, shaderTileImageDepthReadAccess, shaderTileImageStencilReadAccess features are enabled, the render pass must not have been started with vkCmdBeginRendering" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier2-None-08719", + "text": " If fname:vkCmdPipelineBarrier2 is called within a render pass instance started with vkCmdBeginRendering, it must adhere to the restrictions in Explicit Render Pass Tile Image Access Synchronization" + } + ], + "(VK_VERSION_1_3,VK_KHR_synchronization2)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+!(VK_EXT_shader_tile_image)": [ { "vuid": "VUID-vkCmdPipelineBarrier2-None-06191", "text": " If fname:vkCmdPipelineBarrier2 is called within a render pass instance, the render pass must not have been started with vkCmdBeginRendering" @@ -5017,7 +5035,17 @@ "text": " If fname:vkCmdPipelineBarrier is called inside a render pass instance, and there is more than one view in the current subpass, dependency flags must include VK_DEPENDENCY_VIEW_LOCAL_BIT" } ], - "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ + "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdPipelineBarrier-shaderTileImageColorReadAccess-08718", + "text": " If fname:vkCmdPipelineBarrier is called within a render pass instance and none of the shaderTileImageColorReadAccess, shaderTileImageDepthReadAccess, shaderTileImageStencilReadAccess features are enabled, the render pass must not have been started with vkCmdBeginRendering" + }, + { + "vuid": "VUID-vkCmdPipelineBarrier-None-08719", + "text": " If fname:vkCmdPipelineBarrier is called within a render pass instance started with vkCmdBeginRendering, it must adhere to the restrictions in Explicit Render Pass Tile Image Access Synchronization" + } + ], + "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+!(VK_EXT_shader_tile_image)": [ { "vuid": "VUID-vkCmdPipelineBarrier-None-06191", "text": " If fname:vkCmdPipelineBarrier is called within a render pass instance, the render pass must not have been started with vkCmdBeginRendering" @@ -7044,11 +7072,7 @@ }, { "vuid": "VUID-VkImageMemoryBarrier2-image-01672", - "text": " If image has a multi-planar format and the image is disjoint, then the aspectMask member of subresourceRange must include either at least one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, and VK_IMAGE_ASPECT_PLANE_2_BIT; or must include VK_IMAGE_ASPECT_COLOR_BIT" - }, - { - "vuid": "VUID-VkImageMemoryBarrier2-image-01673", - "text": " If image has a multi-planar format with only two planes, then the aspectMask member of subresourceRange must not include VK_IMAGE_ASPECT_PLANE_2_BIT" + "text": " If image has a multi-planar format and the image is disjoint, then the aspectMask member of subresourceRange must include at least one multi-planar aspect mask or VK_IMAGE_ASPECT_COLOR_BIT" } ], "(VK_VERSION_1_3,VK_KHR_synchronization2)+!(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ @@ -7068,11 +7092,11 @@ }, { "vuid": "VUID-VkImageMemoryBarrier2-aspectMask-08702", - "text": " If the aspectMask member of subresourceRange includes VK_IMAGE_ASPECT_DEPTH_BIT, oldLayout and newLayout must not be one of VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + "text": " If the aspectMask member of subresourceRange includes VK_IMAGE_ASPECT_DEPTH_BIT, oldLayout and newLayout must not be one of VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" }, { "vuid": "VUID-VkImageMemoryBarrier2-aspectMask-08703", - "text": " If the aspectMask member of subresourceRange includes VK_IMAGE_ASPECT_STENCIL_BIT, oldLayout and newLayout must not be one of VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL" + "text": " If the aspectMask member of subresourceRange includes VK_IMAGE_ASPECT_STENCIL_BIT, oldLayout and newLayout must not be one of VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL" } ] }, @@ -7282,11 +7306,7 @@ }, { "vuid": "VUID-VkImageMemoryBarrier-image-01672", - "text": " If image has a multi-planar format and the image is disjoint, then the aspectMask member of subresourceRange must include either at least one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, and VK_IMAGE_ASPECT_PLANE_2_BIT; or must include VK_IMAGE_ASPECT_COLOR_BIT" - }, - { - "vuid": "VUID-VkImageMemoryBarrier-image-01673", - "text": " If image has a multi-planar format with only two planes, then the aspectMask member of subresourceRange must not include VK_IMAGE_ASPECT_PLANE_2_BIT" + "text": " If image has a multi-planar format and the image is disjoint, then the aspectMask member of subresourceRange must include at least one multi-planar aspect mask or VK_IMAGE_ASPECT_COLOR_BIT" } ], "!(VK_VERSION_1_2,VK_KHR_separate_depth_stencil_layouts)": [ @@ -7306,11 +7326,11 @@ }, { "vuid": "VUID-VkImageMemoryBarrier-aspectMask-08702", - "text": " If the aspectMask member of subresourceRange includes VK_IMAGE_ASPECT_DEPTH_BIT, oldLayout and newLayout must not be one of VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" + "text": " If the aspectMask member of subresourceRange includes VK_IMAGE_ASPECT_DEPTH_BIT, oldLayout and newLayout must not be one of VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL" }, { "vuid": "VUID-VkImageMemoryBarrier-aspectMask-08703", - "text": " If the aspectMask member of subresourceRange includes VK_IMAGE_ASPECT_STENCIL_BIT, oldLayout and newLayout must not be one of VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL" + "text": " If the aspectMask member of subresourceRange includes VK_IMAGE_ASPECT_STENCIL_BIT, oldLayout and newLayout must not be one of VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL" } ], "!(VK_KHR_synchronization2)+!(VK_VERSION_1_1,VK_KHR_external_memory)": [ @@ -7592,7 +7612,7 @@ }, { "vuid": "VUID-VkRenderingInfo-pNext-07816", - "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, the sum of renderArea.extent.width and renderArea.offset.y must be less than or equal to maxFramebufferHeight" + "text": " If the pNext chain does not contain VkDeviceGroupRenderPassBeginInfo or its deviceRenderAreaCount member is equal to 0, the sum of renderArea.extent.height and renderArea.offset.y must be less than or equal to maxFramebufferHeight" }, { "vuid": "VUID-VkRenderingInfo-pNext-06079", @@ -11256,6 +11276,552 @@ } ] }, + "vkCreateShadersEXT": { + "(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCreateShadersEXT-None-08400", + "text": " The shaderObject feature must be enabled" + }, + { + "vuid": "VUID-vkCreateShadersEXT-pCreateInfos-08401", + "text": " If createInfoCount is 1, there must be no element of pCreateInfos whose flags member includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT" + }, + { + "vuid": "VUID-vkCreateShadersEXT-pCreateInfos-08402", + "text": " If the flags member of any element of pCreateInfos includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT, the flags member of all other elements of pCreateInfos whose stage is VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, VK_SHADER_STAGE_GEOMETRY_BIT, or VK_SHADER_STAGE_FRAGMENT_BIT must also include VK_SHADER_CREATE_LINK_STAGE_BIT_EXT" + }, + { + "vuid": "VUID-vkCreateShadersEXT-pCreateInfos-08409", + "text": " For each element of pCreateInfos whose flags member includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT, if there is any other element of pCreateInfos whose stage is logically later than the stage of the former and whose flags member also includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT, the nextStage of the former must be equal to the stage of the element with the logically earliest stage following the stage of the former whose flags member also includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT" + }, + { + "vuid": "VUID-vkCreateShadersEXT-pCreateInfos-08410", + "text": " The stage member of each element of pCreateInfos whose flags member includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT must be unique" + }, + { + "vuid": "VUID-vkCreateShadersEXT-pCreateInfos-08411", + "text": " The codeType member of all elements of pCreateInfos whose flags member includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT must be the same" + }, + { + "vuid": "VUID-vkCreateShadersEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkCreateShadersEXT-pCreateInfos-parameter", + "text": " pCreateInfos must be a valid pointer to an array of createInfoCount valid VkShaderCreateInfoEXT structures" + }, + { + "vuid": "VUID-vkCreateShadersEXT-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkCreateShadersEXT-pShaders-parameter", + "text": " pShaders must be a valid pointer to an array of createInfoCount VkShaderEXT handles" + }, + { + "vuid": "VUID-vkCreateShadersEXT-createInfoCount-arraylength", + "text": " createInfoCount must be greater than 0" + } + ], + "(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCreateShadersEXT-pCreateInfos-08403", + "text": " If the flags member of any element of pCreateInfos includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT, the flags member of all other elements of pCreateInfos whose stage is VK_SHADER_STAGE_TASK_BIT_EXT or VK_SHADER_STAGE_MESH_BIT_EXT must also include VK_SHADER_CREATE_LINK_STAGE_BIT_EXT" + }, + { + "vuid": "VUID-vkCreateShadersEXT-pCreateInfos-08404", + "text": " If the flags member of any element of pCreateInfos whose stage is VK_SHADER_STAGE_TASK_BIT_EXT or VK_SHADER_STAGE_MESH_BIT_EXT includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT, there must be no member of pCreateInfos whose stage is VK_SHADER_STAGE_VERTEX_BIT and whose flags member includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT" + }, + { + "vuid": "VUID-vkCreateShadersEXT-pCreateInfos-08405", + "text": " If there is any element of pCreateInfos whose stage is VK_SHADER_STAGE_MESH_BIT_EXT and whose flags member includes both VK_SHADER_CREATE_LINK_STAGE_BIT_EXT and VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT, there must be no element of pCreateInfos whose stage is VK_SHADER_STAGE_TASK_BIT_EXT and whose flags member includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT" + } + ], + "(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCreateShadersEXT-pCreateInfos-08406", + "text": " If the flags member of any element of pCreateInfos includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT, the flags member of all other elements of pCreateInfos whose stage is VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV must also include VK_SHADER_CREATE_LINK_STAGE_BIT_EXT" + }, + { + "vuid": "VUID-vkCreateShadersEXT-pCreateInfos-08407", + "text": " If the flags member of any element of pCreateInfos whose stage is VK_SHADER_STAGE_TASK_BIT_NV or VK_SHADER_STAGE_MESH_BIT_NV includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT, there must be no member of pCreateInfos whose stage is VK_SHADER_STAGE_VERTEX_BIT and whose flags member includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT" + }, + { + "vuid": "VUID-vkCreateShadersEXT-pCreateInfos-08408", + "text": " If there is any element of pCreateInfos whose stage is VK_SHADER_STAGE_MESH_BIT_NV and whose flags includes both VK_SHADER_CREATE_LINK_STAGE_BIT_EXT and VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT, there must be no element of pCreateInfos whose stage is VK_SHADER_STAGE_TASK_BIT_NV and whose flags includes VK_SHADER_CREATE_LINK_STAGE_BIT_EXT" + } + ] + }, + "VkShaderCreateInfoEXT": { + "(VK_EXT_shader_object)": [ + { + "vuid": "VUID-VkShaderCreateInfoEXT-flags-08412", + "text": " If stage is not VK_SHADER_STAGE_TASK_BIT_EXT, VK_SHADER_STAGE_MESH_BIT_EXT, VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, VK_SHADER_STAGE_GEOMETRY_BIT, or VK_SHADER_STAGE_FRAGMENT_BIT, flags must not include VK_SHADER_CREATE_LINK_STAGE_BIT_EXT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-flags-08413", + "text": " If stage is not VK_SHADER_STAGE_COMPUTE_BIT, flags must not include VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT or VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-flags-08416", + "text": " If flags includes both VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT and VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT, the local workgroup size in the X dimension of the shader must be a multiple of maxSubgroupSize" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-flags-08417", + "text": " If flags includes VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT but not VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT and no VkShaderRequiredSubgroupSizeCreateInfoEXT structure is included in the pNext chain, the local workgroup size in the X dimension of the shader must be a multiple of subgroupSize" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-stage-08418", + "text": " stage must not be VK_SHADER_STAGE_ALL_GRAPHICS or VK_SHADER_STAGE_ALL" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-stage-08419", + "text": " If the tessellationShader feature is not enabled, stage must not be VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-stage-08420", + "text": " If the geometryShader feature is not enabled, stage must not be VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-nextStage-08427", + "text": " If stage is VK_SHADER_STAGE_VERTEX_BIT, nextStage must not include any bits other than VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_GEOMETRY_BIT, and VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-nextStage-08428", + "text": " If stage is VK_SHADER_STAGE_VERTEX_BIT and the tessellationShader feature is not enabled, nextStage must not include VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-nextStage-08429", + "text": " If stage is VK_SHADER_STAGE_VERTEX_BIT and the geometryShader feature is not enabled, nextStage must not include VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-nextStage-08430", + "text": " If stage is VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, nextStage must not include any bits other than VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-nextStage-08431", + "text": " If stage is VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, nextStage must not include any bits other than VK_SHADER_STAGE_GEOMETRY_BIT and VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-nextStage-08432", + "text": " If stage is VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT and the geometryShader feature is not enabled, nextStage must not include VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-nextStage-08433", + "text": " If stage is VK_SHADER_STAGE_GEOMETRY_BIT, nextStage must not include any bits other than VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-nextStage-08434", + "text": " If stage is VK_SHADER_STAGE_FRAGMENT_BIT or VK_SHADER_STAGE_COMPUTE_BIT, nextStage must be 0" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-codeSize-08439", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, codeSize must be a multiple of 4" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pName-08440", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, pName must be the name of an OpEntryPoint in pCode with an execution model that matches stage" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08441", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, pCode must point to valid SPIR-V code, formatted and packed as described by the Khronos SPIR-V Specification" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08442", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, pCode must adhere to the validation rules described by the Validation Rules within a Module section of the SPIR-V Environment appendix" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08443", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, pCode must declare the Shader capability for SPIR-V code" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08444", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, pCode must not declare any capability that is not supported by the API, as described by the Capabilities section of the SPIR-V Environment appendix" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08445", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and pCode declares any of the capabilities listed in the SPIR-V Environment appendix, one of the corresponding requirements must be satisfied" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08446", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, pCode must not declare any SPIR-V extension that is not supported by the API, as described by the Extension section of the SPIR-V Environment appendix" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08447", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and pCode declares any of the SPIR-V extensions listed in the SPIR-V Environment appendix, one of the corresponding requirements must be satisfied" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08448", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and the identified entry point includes any variable in its interface that is declared with the ClipDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxClipDistances" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08449", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and the identified entry point includes any variable in its interface that is declared with the CullDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxCullDistances" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08450", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and the identified entry point includes any variables in its interface that are declared with the ClipDistance or CullDistance BuiltIn decoration, those variables must not have array sizes which sum to more than VkPhysicalDeviceLimits::maxCombinedClipAndCullDistances" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08451", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and the identified entry point includes any variable in its interface that is declared with the SampleMask BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxSampleMaskWords" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08452", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and stage is VK_SHADER_STAGE_VERTEX_BIT, the identified entry point must not include any input variable in its interface that is decorated with CullDistance" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08453", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and stage is VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, and the identified entry point has an OpExecutionMode instruction specifying a patch size with OutputVertices, the patch size must be greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08454", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction specifying a maximum output vertex count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryOutputVertices" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08455", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and stage is VK_SHADER_STAGE_GEOMETRY_BIT, the identified entry point must have an OpExecutionMode instruction specifying an invocation count that is greater than 0 and less than or equal to VkPhysicalDeviceLimits::maxGeometryShaderInvocations" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08456", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and stage is a pre-rasterization shader stage, and the identified entry point writes to Layer for any primitive, it must write the same value to Layer for all vertices of a given primitive" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08457", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and stage is a pre-rasterization shader stage, and the identified entry point writes to ViewportIndex for any primitive, it must write the same value to ViewportIndex for all vertices of a given primitive" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08458", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and stage is VK_SHADER_STAGE_FRAGMENT_BIT, the identified entry point must not include any output variables in its interface decorated with CullDistance" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08459", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, and stage is VK_SHADER_STAGE_FRAGMENT_BIT, and the identified entry point writes to FragDepth in any execution path, all execution paths that are not exclusive to helper invocations must either discard the fragment, or write or initialize the value of FragDepth" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-08460", + "text": " If codeType is VK_SHADER_CODE_TYPE_SPIRV_EXT, the shader code in pCode must be valid as described by the Khronos SPIR-V Specification after applying the specializations provided in pSpecializationInfo, if any, and then converting all specialization constants into fixed constants" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pNext-pNext", + "text": " pNext must be NULL or a pointer to a valid instance of VkPipelineShaderStageRequiredSubgroupSizeCreateInfo" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-sType-unique", + "text": " The sType value of each struct in the pNext chain must be unique" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-flags-parameter", + "text": " flags must be a valid combination of VkShaderCreateFlagBitsEXT values" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-stage-parameter", + "text": " stage must be a valid VkShaderStageFlagBits value" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-nextStage-parameter", + "text": " nextStage must be a valid combination of VkShaderStageFlagBits values" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-codeType-parameter", + "text": " codeType must be a valid VkShaderCodeTypeEXT value" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pCode-parameter", + "text": " pCode must be a valid pointer to an array of codeSize bytes" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pName-parameter", + "text": " If pName is not NULL, pName must be a null-terminated UTF-8 string" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pSetLayouts-parameter", + "text": " If setLayoutCount is not 0, and pSetLayouts is not NULL, pSetLayouts must be a valid pointer to an array of setLayoutCount valid VkDescriptorSetLayout handles" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pPushConstantRanges-parameter", + "text": " If pushConstantRangeCount is not 0, and pPushConstantRanges is not NULL, pPushConstantRanges must be a valid pointer to an array of pushConstantRangeCount valid VkPushConstantRange structures" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-pSpecializationInfo-parameter", + "text": " If pSpecializationInfo is not NULL, pSpecializationInfo must be a valid pointer to a valid VkSpecializationInfo structure" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-codeSize-arraylength", + "text": " codeSize must be greater than 0" + } + ], + "(VK_EXT_shader_object)+(VK_KHR_fragment_shading_rate)": [ + { + "vuid": "VUID-VkShaderCreateInfoEXT-flags-08486", + "text": " If stage is not VK_SHADER_STAGE_FRAGMENT_BIT, flags must not include VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-flags-08487", + "text": " If the attachmentFragmentShadingRate feature is not enabled, flags must not include VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT" + } + ], + "(VK_EXT_shader_object)+(VK_EXT_fragment_density_map)": [ + { + "vuid": "VUID-VkShaderCreateInfoEXT-flags-08488", + "text": " If stage is not VK_SHADER_STAGE_FRAGMENT_BIT, flags must not include VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-flags-08489", + "text": " If the fragmentDensityMap feature is not enabled, flags must not include VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT" + } + ], + "(VK_EXT_shader_object)+(VK_VERSION_1_1,VK_KHR_device_group)": [ + { + "vuid": "VUID-VkShaderCreateInfoEXT-flags-08485", + "text": " If stage is not VK_SHADER_STAGE_COMPUTE_BIT, flags must not include VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT" + } + ], + "(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-VkShaderCreateInfoEXT-flags-08414", + "text": " If stage is not VK_SHADER_STAGE_MESH_BIT_EXT, flags must not include VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-stage-08421", + "text": " If the taskShader feature is not enabled, stage must not be VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-stage-08422", + "text": " If the meshShader feature is not enabled, stage must not be VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-nextStage-08435", + "text": " If stage is VK_SHADER_STAGE_TASK_BIT_EXT, nextStage must not include any bits other than VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-nextStage-08436", + "text": " If stage is VK_SHADER_STAGE_MESH_BIT_EXT, nextStage must not include any bits other than VK_SHADER_STAGE_FRAGMENT_BIT" + } + ], + "(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-VkShaderCreateInfoEXT-flags-08415", + "text": " If stage is not VK_SHADER_STAGE_MESH_BIT_NV, flags must not include VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-stage-08423", + "text": " If the taskShader feature is not enabled, stage must not be VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-stage-08424", + "text": " If the meshShader feature is not enabled, stage must not be VK_SHADER_STAGE_MESH_BIT_NV" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-nextStage-08437", + "text": " If stage is VK_SHADER_STAGE_TASK_BIT_NV, nextStage must not include any bits other than VK_SHADER_STAGE_MESH_BIT_NV" + }, + { + "vuid": "VUID-VkShaderCreateInfoEXT-nextStage-08438", + "text": " If stage is VK_SHADER_STAGE_MESH_BIT_NV, nextStage must not include any bits other than VK_SHADER_STAGE_FRAGMENT_BIT" + } + ], + "(VK_EXT_shader_object)+(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-VkShaderCreateInfoEXT-stage-08425", + "text": " stage must not be VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI" + } + ], + "(VK_EXT_shader_object)+(VK_HUAWEI_cluster_culling_shader)": [ + { + "vuid": "VUID-VkShaderCreateInfoEXT-stage-08426", + "text": " stage must not be VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI" + } + ] + }, + "vkGetShaderBinaryDataEXT": { + "(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkGetShaderBinaryDataEXT-None-08461", + "text": " The shaderObject feature must be enabled" + }, + { + "vuid": "VUID-vkGetShaderBinaryDataEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkGetShaderBinaryDataEXT-shader-parameter", + "text": " shader must be a valid VkShaderEXT handle" + }, + { + "vuid": "VUID-vkGetShaderBinaryDataEXT-pDataSize-parameter", + "text": " pDataSize must be a valid pointer to a size_t value" + }, + { + "vuid": "VUID-vkGetShaderBinaryDataEXT-pData-parameter", + "text": " If the value referenced by pDataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of pDataSize bytes" + }, + { + "vuid": "VUID-vkGetShaderBinaryDataEXT-shader-parent", + "text": " shader must have been created, allocated, or retrieved from device" + } + ] + }, + "vkCmdBindShadersEXT": { + "(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdBindShadersEXT-None-08462", + "text": " The shaderObject feature must be enabled" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-pStages-08463", + "text": " Every element of pStages must be unique" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-pStages-08464", + "text": " pStages must not contain VK_SHADER_STAGE_ALL_GRAPHICS or VK_SHADER_STAGE_ALL" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-pShaders-08469", + "text": " For each element of pStages, if pShaders is not NULL, and the element of the pShaders array with the same index is not VK_NULL_HANDLE, it must have been created with a stage equal to the corresponding element of pStages" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-pShaders-08474", + "text": " If the tessellationShader feature is not enabled, and pStages contains VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT or VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, and pShaders is not NULL, the same index or indices in pShaders must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-pShaders-08475", + "text": " If the geometryShader feature is not enabled, and pStages contains VK_SHADER_STAGE_GEOMETRY_BIT, and pShaders is not NULL, the same index in pShaders must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-pShaders-08476", + "text": " If pStages contains VK_SHADER_STAGE_COMPUTE_BIT, the VkCommandPool that commandBuffer was allocated from must support compute operations" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-pShaders-08477", + "text": " If pStages contains VK_SHADER_STAGE_VERTEX_BIT, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, VK_SHADER_STAGE_GEOMETRY_BIT, or VK_SHADER_STAGE_FRAGMENT_BIT, the VkCommandPool that commandBuffer was allocated from must support graphics operations" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-commandBuffer-parameter", + "text": " commandBuffer must be a valid VkCommandBuffer handle" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-pStages-parameter", + "text": " pStages must be a valid pointer to an array of stageCount valid VkShaderStageFlagBits values" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-pShaders-parameter", + "text": " If pShaders is not NULL, pShaders must be a valid pointer to an array of stageCount valid or VK_NULL_HANDLE VkShaderEXT handles" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-commandBuffer-recording", + "text": " commandBuffer must be in the recording state" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-commandBuffer-cmdpool", + "text": " The VkCommandPool that commandBuffer was allocated from must support graphics, or compute operations" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-videocoding", + "text": " This command must only be called outside of a video coding scope" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-stageCount-arraylength", + "text": " stageCount must be greater than 0" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-commonparent", + "text": " Both of commandBuffer, and the elements of pShaders that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" + } + ], + "(VK_EXT_shader_object)+(VK_KHR_ray_tracing_pipeline)": [ + { + "vuid": "VUID-vkCmdBindShadersEXT-pStages-08465", + "text": " pStages must not contain VK_SHADER_STAGE_RAYGEN_BIT_KHR, VK_SHADER_STAGE_ANY_HIT_BIT_KHR, VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, VK_SHADER_STAGE_MISS_BIT_KHR, VK_SHADER_STAGE_INTERSECTION_BIT_KHR, or VK_SHADER_STAGE_CALLABLE_BIT_KHR" + } + ], + "(VK_EXT_shader_object)+!(VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)": [ + { + "vuid": "VUID-vkCmdBindShadersEXT-pStages-08466", + "text": " pStages must not contain VK_SHADER_STAGE_RAYGEN_BIT_NV, VK_SHADER_STAGE_ANY_HIT_BIT_NV, VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV, VK_SHADER_STAGE_MISS_BIT_NV, VK_SHADER_STAGE_INTERSECTION_BIT_NV, or VK_SHADER_STAGE_CALLABLE_BIT_NV" + } + ], + "(VK_EXT_shader_object)+(VK_HUAWEI_subpass_shading)": [ + { + "vuid": "VUID-vkCmdBindShadersEXT-pStages-08467", + "text": " pStages must not contain VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI" + } + ], + "(VK_EXT_shader_object)+(VK_HUAWEI_cluster_culling_shader)": [ + { + "vuid": "VUID-vkCmdBindShadersEXT-pStages-08468", + "text": " pStages must not contain VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI" + } + ], + "(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdBindShadersEXT-pShaders-08470", + "text": " If pStages contains both VK_SHADER_STAGE_TASK_BIT_EXT and VK_SHADER_STAGE_VERTEX_BIT, and pShaders is not NULL, and the same index in pShaders as VK_SHADER_STAGE_TASK_BIT_EXT in pStages is not VK_NULL_HANDLE, the same index in pShaders as VK_SHADER_STAGE_VERTEX_BIT in pStages must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-pShaders-08471", + "text": " If pStages contains both VK_SHADER_STAGE_MESH_BIT_EXT and VK_SHADER_STAGE_VERTEX_BIT, and pShaders is not NULL, and the same index in pShaders as VK_SHADER_STAGE_MESH_BIT_EXT in pStages is not VK_NULL_HANDLE, the same index in pShaders as VK_SHADER_STAGE_VERTEX_BIT in pStages must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-pShaders-08478", + "text": " If pStages contains VK_SHADER_STAGE_MESH_BIT_EXT or VK_SHADER_STAGE_TASK_BIT_EXT, the VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ], + "(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdBindShadersEXT-pShaders-08472", + "text": " If pStages contains both VK_SHADER_STAGE_TASK_BIT_NV and VK_SHADER_STAGE_VERTEX_BIT, and pShaders is not NULL, and the same index in pShaders as VK_SHADER_STAGE_TASK_BIT_NV in pStages is not VK_NULL_HANDLE, the same index in pShaders as VK_SHADER_STAGE_VERTEX_BIT in pStages must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-pShaders-08473", + "text": " If pStages contains both VK_SHADER_STAGE_MESH_BIT_NV and VK_SHADER_STAGE_VERTEX_BIT, and pShaders is not NULL, and the same index in pShaders as VK_SHADER_STAGE_MESH_BIT_NV in pStages is not VK_NULL_HANDLE, the same index in pShaders as VK_SHADER_STAGE_VERTEX_BIT in pStages must be VK_NULL_HANDLE" + }, + { + "vuid": "VUID-vkCmdBindShadersEXT-pShaders-08480", + "text": " If pStages contains VK_SHADER_STAGE_MESH_BIT_NV or VK_SHADER_STAGE_TASK_BIT_NV, the VkCommandPool that commandBuffer was allocated from must support graphics operations" + } + ] + }, + "vkDestroyShaderEXT": { + "(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkDestroyShaderEXT-None-08481", + "text": " The shaderObject feature must be enabled" + }, + { + "vuid": "VUID-vkDestroyShaderEXT-shader-08482", + "text": " All submitted commands that refer to shader must have completed execution" + }, + { + "vuid": "VUID-vkDestroyShaderEXT-pAllocator-08483", + "text": " If VkAllocationCallbacks were provided when shader was created, a compatible set of callbacks must be provided here" + }, + { + "vuid": "VUID-vkDestroyShaderEXT-pAllocator-08484", + "text": " If no VkAllocationCallbacks were provided when shader was created, pAllocator must be NULL" + }, + { + "vuid": "VUID-vkDestroyShaderEXT-device-parameter", + "text": " device must be a valid VkDevice handle" + }, + { + "vuid": "VUID-vkDestroyShaderEXT-shader-parameter", + "text": " shader must be a valid VkShaderEXT handle" + }, + { + "vuid": "VUID-vkDestroyShaderEXT-pAllocator-parameter", + "text": " If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure" + }, + { + "vuid": "VUID-vkDestroyShaderEXT-shader-parent", + "text": " shader must have been created, allocated, or retrieved from device" + } + ] + }, "vkCreateShaderModule": { "(VK_EXT_validation_cache)": [ { @@ -11461,11 +12027,25 @@ ] }, "vkCmdSetPatchControlPointsEXT": { - "(VK_EXT_extended_dynamic_state2)": [ + "(VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetPatchControlPointsEXT-None-08574", + "text": " Either the extendedDynamicState2PatchControlPoints feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetPatchControlPointsEXT-None-08575", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetPatchControlPointsEXT-None-04873", "text": " The extendedDynamicState2PatchControlPoints feature must be enabled" - }, + } + ], + "(VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetPatchControlPointsEXT-patchControlPoints-04874", "text": " patchControlPoints must be greater than zero and less than or equal to VkPhysicalDeviceLimits::maxTessellationPatchSize" @@ -13279,6 +13859,12 @@ "text": " If renderPass is VK_NULL_HANDLE, the pipeline is being created with pre-rasterization shader state, and VkPipelineRenderingCreateInfo::viewMask is not 0, and multiviewMeshShader is not enabled, then pStages must not include a mesh shader" } ], + "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_multiview,VK_VERSION_1_1)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-08710", + "text": " If the pipeline is being created with fragment shader state and renderPass is not VK_NULL_HANDLE, fragment shaders in pStages must not include any of the TileImageColorReadAccessEXT, TileImageDepthReadAccessEXT, or TileImageStencilReadAccessEXT capabilities" + } + ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_AMD_mixed_attachment_samples,VK_NV_framebuffer_mixed_samples)": [ { "vuid": "VUID-VkGraphicsPipelineCreateInfo-renderPass-06063", @@ -13628,7 +14214,17 @@ }, { "vuid": "VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-07731", - "text": " If the pipeline is being created with pre-rasterization shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SCISSOR or VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, and if multiviewPerViewViewports is enabled, then the index of the most significant bit in each element of VkRenderPassMultiviewCreateInfo::pViewMasks must be less than pViewportState::scissorCount" + "text": " If the pipeline is being created with pre-rasterization shader state, and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SCISSOR or VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, and if multiviewPerViewViewports is enabled, then the index of the most significant bit in each element of VkRenderPassMultiviewCreateInfo::pViewMasks must be less than pViewportState::scissorCount" + } + ], + "(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-08711", + "text": " If pStages includes a fragment shader stage, VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE is not set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable member of VkPipelineDepthStencilStateCreateInfo must be VK_FALSE" + }, + { + "vuid": "VUID-VkGraphicsPipelineCreateInfo-pStages-08712", + "text": " If pStages includes a fragment shader stage, VK_DYNAMIC_STATE_STENCIL_WRITE_MASK is not set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the value of slink::VkStencilOpState::writeMask for both front and back in VkPipelineDepthStencilStateCreateInfo must be 0" } ] }, @@ -14158,7 +14754,7 @@ }, { "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-08700", - "text": " If flags does not include VK_PIPELINE_CREATE_LIBRARY_BIT_KHR and either pLibraryInfo is NULL or its libraryCount is 0, groupCount must not be 0" + "text": " If flags does not include VK_PIPELINE_CREATE_LIBRARY_BIT_KHR and either pLibraryInfo is NULL or its libraryCount is 0, groupCount must not be 0" }, { "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-pDynamicStates-03602", @@ -14302,7 +14898,7 @@ "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_NV_displacement_micromap)": [ { "vuid": "VUID-VkRayTracingPipelineCreateInfoKHR-flags-08701", - "text": " If flags includes VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV, each element of pLibraryInfo->pLibraries must have been created with the VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV bit set" + "text": " If flags includes VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV, each element of pLibraryInfo->pLibraries must have been created with the VK_PIPELINE_CREATE_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV bit set" } ] }, @@ -18437,12 +19033,8 @@ ], "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ { - "vuid": "VUID-vkGetImageSubresourceLayout-format-01581", - "text": " If the tiling of the image is VK_IMAGE_TILING_LINEAR and its format is a multi-planar format with two planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" - }, - { - "vuid": "VUID-vkGetImageSubresourceLayout-format-01582", - "text": " If the tiling of the image is VK_IMAGE_TILING_LINEAR and its format is a multi-planar format with three planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT" + "vuid": "VUID-vkGetImageSubresourceLayout-tiling-08717", + "text": " If the tiling of the image is VK_IMAGE_TILING_LINEAR and has a multi-planar image format, then the aspectMask member of pSubresource must be a single valid multi-planar aspect mask" } ], "(VK_ANDROID_external_memory_android_hardware_buffer)": [ @@ -18517,12 +19109,8 @@ ], "(VK_EXT_image_compression_control)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ { - "vuid": "VUID-vkGetImageSubresourceLayout2EXT-format-01581", - "text": " If the tiling of the image is VK_IMAGE_TILING_LINEAR and its format is a multi-planar format with two planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" - }, - { - "vuid": "VUID-vkGetImageSubresourceLayout2EXT-format-01582", - "text": " If the tiling of the image is VK_IMAGE_TILING_LINEAR and its format is a multi-planar format with three planes, the aspectMask member of pSubresource must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT" + "vuid": "VUID-vkGetImageSubresourceLayout2EXT-tiling-08717", + "text": " If the tiling of the image is VK_IMAGE_TILING_LINEAR and has a multi-planar image format, then the aspectMask member of pSubresource must be a single valid multi-planar aspect mask" } ], "(VK_EXT_image_compression_control)+(VK_ANDROID_external_memory_android_hardware_buffer)": [ @@ -18910,11 +19498,11 @@ "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ { "vuid": "VUID-VkImageViewCreateInfo-image-01586", - "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, if the format of the image is a multi-planar format, and if subresourceRange.aspectMask is one of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT, then format must be compatible with the VkFormat for the plane of the image format indicated by subresourceRange.aspectMask, as defined in Compatible formats of planes of multi-planar formats" + "text": " If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, if the format of the image is a multi-planar format, and if subresourceRange.aspectMask is one of the multi-planar aspect masks, then format must be compatible with the VkFormat for the plane of the image format indicated by subresourceRange.aspectMask, as defined in Compatible formats of planes of multi-planar formats" }, { "vuid": "VUID-VkImageViewCreateInfo-subresourceRange-07818", - "text": " If subresourceRange.aspectMask contains any of VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT, then it must only have a single bit set" + "text": " subresourceRange.aspectMask must only have at most 1 valid multi-planar aspect mask" }, { "vuid": "VUID-VkImageViewCreateInfo-image-01762", @@ -20438,7 +21026,7 @@ }, { "vuid": "VUID-VkDeviceImageMemoryRequirementsKHR-pCreateInfo-06419", - "text": " If pCreateInfo::flags has VK_IMAGE_CREATE_DISJOINT_BIT set and if the pCreateInfo::tiling is VK_IMAGE_TILING_LINEAR or VK_IMAGE_TILING_OPTIMAL, then planeAspect must be a single valid format plane for the image (that is, for a two-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT, and for a three-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT)" + "text": " If pCreateInfo::flags has VK_IMAGE_CREATE_DISJOINT_BIT set and if the pCreateInfo::tiling is VK_IMAGE_TILING_LINEAR or VK_IMAGE_TILING_OPTIMAL, then planeAspect must be a single valid multi-planar aspect mask" }, { "vuid": "VUID-VkDeviceImageMemoryRequirements-sType-sType", @@ -20478,7 +21066,7 @@ "(VK_VERSION_1_1,VK_KHR_get_memory_requirements2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ { "vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-02281", - "text": " If the image’s tiling is VK_IMAGE_TILING_LINEAR or VK_IMAGE_TILING_OPTIMAL, then planeAspect must be a single valid format plane for the image (that is, for a two-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT, and for a three-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT)" + "text": " If the image’s tiling is VK_IMAGE_TILING_LINEAR or VK_IMAGE_TILING_OPTIMAL, then planeAspect must be a single valid multi-planar aspect mask" }, { "vuid": "VUID-VkImagePlaneMemoryRequirementsInfo-sType-sType", @@ -21266,7 +21854,7 @@ "(VK_VERSION_1_1,VK_KHR_bind_memory2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ { "vuid": "VUID-VkBindImagePlaneMemoryInfo-planeAspect-02283", - "text": " If the image’s tiling is VK_IMAGE_TILING_LINEAR or VK_IMAGE_TILING_OPTIMAL, then planeAspect must be a single valid format plane for the image (that is, for a two-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT, and for a three-plane image planeAspect must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or VK_IMAGE_ASPECT_PLANE_2_BIT)" + "text": " If the image’s tiling is VK_IMAGE_TILING_LINEAR or VK_IMAGE_TILING_OPTIMAL, then planeAspect must be a single valid multi-planar aspect mask" }, { "vuid": "VUID-VkBindImagePlaneMemoryInfo-sType-sType", @@ -23410,10 +23998,6 @@ "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00336", "text": " If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with the identity swizzle" }, - { - "vuid": "VUID-VkWriteDescriptorSet-descriptorType-07729", - "text": " If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with exactly one aspect" - }, { "vuid": "VUID-VkWriteDescriptorSet-descriptorType-00337", "text": " If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_SAMPLED_BIT set" @@ -23612,7 +24196,7 @@ "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ { "vuid": "VUID-VkDescriptorImageInfo-sampler-01564", - "text": " If sampler is used and the VkFormat of the image is a multi-planar format, the image must have been created with VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, and the aspectMask of the imageView must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT or (for three-plane formats only) VK_IMAGE_ASPECT_PLANE_2_BIT" + "text": " If sampler is used and the VkFormat of the image is a multi-planar format, the image must have been created with VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, and the aspectMask of the imageView must be a valid multi-planar aspect mask" } ], "(VK_KHR_portability_subset)": [ @@ -29677,20 +30261,12 @@ "text": " If neither srcImage nor dstImage has a multi-planar image format then for each element of pRegions, srcSubresource.aspectMask and dstSubresource.aspectMask must match" }, { - "vuid": "VUID-vkCmdCopyImage-srcImage-01552", - "text": " If srcImage has a VkFormat with two planes then for each element of pRegions, srcSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" + "vuid": "VUID-vkCmdCopyImage-srcImage-08713", + "text": " If srcImage has a multi-planar image format, then for each element of pRegions, srcSubresource.aspectMask must be a single valid multi-planar aspect mask" }, { - "vuid": "VUID-vkCmdCopyImage-srcImage-01553", - "text": " If srcImage has a VkFormat with three planes then for each element of pRegions, srcSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstImage-01554", - "text": " If dstImage has a VkFormat with two planes then for each element of pRegions, dstSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" - }, - { - "vuid": "VUID-vkCmdCopyImage-dstImage-01555", - "text": " If dstImage has a VkFormat with three planes then for each element of pRegions, dstSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" + "vuid": "VUID-vkCmdCopyImage-dstImage-08714", + "text": " If dstImage has a multi-planar image format, then for each element of pRegions, dstSubresource.aspectMask must be a single valid multi-planar aspect mask" }, { "vuid": "VUID-vkCmdCopyImage-srcImage-01556", @@ -30159,20 +30735,12 @@ "text": " If neither srcImage nor dstImage has a multi-planar image format then for each element of pRegions, srcSubresource.aspectMask and dstSubresource.aspectMask must match" }, { - "vuid": "VUID-VkCopyImageInfo2-srcImage-01552", - "text": " If srcImage has a VkFormat with two planes then for each element of pRegions, srcSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" + "vuid": "VUID-VkCopyImageInfo2-srcImage-08713", + "text": " If srcImage has a multi-planar image format, then for each element of pRegions, srcSubresource.aspectMask must be a single valid multi-planar aspect mask" }, { - "vuid": "VUID-VkCopyImageInfo2-srcImage-01553", - "text": " If srcImage has a VkFormat with three planes then for each element of pRegions, srcSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" - }, - { - "vuid": "VUID-VkCopyImageInfo2-dstImage-01554", - "text": " If dstImage has a VkFormat with two planes then for each element of pRegions, dstSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT or VK_IMAGE_ASPECT_PLANE_1_BIT" - }, - { - "vuid": "VUID-VkCopyImageInfo2-dstImage-01555", - "text": " If dstImage has a VkFormat with three planes then for each element of pRegions, dstSubresource.aspectMask must be VK_IMAGE_ASPECT_PLANE_0_BIT, VK_IMAGE_ASPECT_PLANE_1_BIT, or VK_IMAGE_ASPECT_PLANE_2_BIT" + "vuid": "VUID-VkCopyImageInfo2-dstImage-08714", + "text": " If dstImage has a multi-planar image format, then for each element of pRegions, dstSubresource.aspectMask must be a single valid multi-planar aspect mask" }, { "vuid": "VUID-VkCopyImageInfo2-srcImage-01556", @@ -30308,7 +30876,7 @@ }, { "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-07974", - "text": " If pname:dstImage does not have a depth/stencil format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + "text": " If pname:dstImage does not have a depth/stencil format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" } ], "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ @@ -30326,7 +30894,7 @@ }, { "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-07975", - "text": " If pname:dstImage does not have either a depth/stencil or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + "text": " If pname:dstImage does not have either a depth/stencil or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the texel block size" }, { "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-07976", @@ -30426,10 +30994,6 @@ "vuid": "VUID-vkCmdCopyBufferToImage-pRegions-07277", "text": " For each element of pRegions, bufferRowLength divided by the texel block extent width and then multiplied by the texel block size of pname:dstImage must be less than or equal to 231-1" }, - { - "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-07977", - "text": " For each element of pRegions, bufferOffset must be a multiple of the texel block size of the VkFormat of pname:dstImage" - }, { "vuid": "VUID-vkCmdCopyBufferToImage-dstImage-07978", "text": " If pname:dstImage has a depth/stencil format, the bufferOffset member of any element of pRegions must be a multiple of 4" @@ -30562,7 +31126,7 @@ }, { "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-07974", - "text": " If pname:srcImage does not have a depth/stencil format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + "text": " If pname:srcImage does not have a depth/stencil format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" } ], "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ @@ -30580,7 +31144,7 @@ }, { "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-07975", - "text": " If pname:srcImage does not have either a depth/stencil or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + "text": " If pname:srcImage does not have either a depth/stencil or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the texel block size" }, { "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-07976", @@ -30676,10 +31240,6 @@ "vuid": "VUID-vkCmdCopyImageToBuffer-pRegions-07277", "text": " For each element of pRegions, bufferRowLength divided by the texel block extent width and then multiplied by the texel block size of pname:srcImage must be less than or equal to 231-1" }, - { - "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-07977", - "text": " For each element of pRegions, bufferOffset must be a multiple of the texel block size of the VkFormat of pname:srcImage" - }, { "vuid": "VUID-vkCmdCopyImageToBuffer-srcImage-07978", "text": " If pname:srcImage has a depth/stencil format, the bufferOffset member of any element of pRegions must be a multiple of 4" @@ -31000,10 +31560,6 @@ "vuid": "VUID-VkCopyBufferToImageInfo2-pRegions-07277", "text": " For each element of pRegions, bufferRowLength divided by the texel block extent width and then multiplied by the texel block size of pname:dstImage must be less than or equal to 231-1" }, - { - "vuid": "VUID-VkCopyBufferToImageInfo2-dstImage-07977", - "text": " For each element of pRegions, bufferOffset must be a multiple of the texel block size of the VkFormat of pname:dstImage" - }, { "vuid": "VUID-VkCopyBufferToImageInfo2-dstImage-07978", "text": " If pname:dstImage has a depth/stencil format, the bufferOffset member of any element of pRegions must be a multiple of 4" @@ -31086,7 +31642,7 @@ }, { "vuid": "VUID-VkCopyBufferToImageInfo2-dstImage-07974", - "text": " If pname:dstImage does not have a depth/stencil format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + "text": " If pname:dstImage does not have a depth/stencil format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" } ], "(VK_VERSION_1_3,VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ @@ -31104,7 +31660,7 @@ }, { "vuid": "VUID-VkCopyBufferToImageInfo2-dstImage-07975", - "text": " If pname:dstImage does not have either a depth/stencil or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + "text": " If pname:dstImage does not have either a depth/stencil or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the texel block size" }, { "vuid": "VUID-VkCopyBufferToImageInfo2-dstImage-07976", @@ -31290,10 +31846,6 @@ "vuid": "VUID-VkCopyImageToBufferInfo2-pRegions-07277", "text": " For each element of pRegions, bufferRowLength divided by the texel block extent width and then multiplied by the texel block size of pname:srcImage must be less than or equal to 231-1" }, - { - "vuid": "VUID-VkCopyImageToBufferInfo2-srcImage-07977", - "text": " For each element of pRegions, bufferOffset must be a multiple of the texel block size of the VkFormat of pname:srcImage" - }, { "vuid": "VUID-VkCopyImageToBufferInfo2-srcImage-07978", "text": " If pname:srcImage has a depth/stencil format, the bufferOffset member of any element of pRegions must be a multiple of 4" @@ -31364,7 +31916,7 @@ }, { "vuid": "VUID-VkCopyImageToBufferInfo2-srcImage-07974", - "text": " If pname:srcImage does not have a depth/stencil format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + "text": " If pname:srcImage does not have a depth/stencil format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" } ], "(VK_VERSION_1_3,VK_KHR_copy_commands2)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ @@ -31382,7 +31934,7 @@ }, { "vuid": "VUID-VkCopyImageToBufferInfo2-srcImage-07975", - "text": " If pname:srcImage does not have either a depth/stencil or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the format’s texel block size" + "text": " If pname:srcImage does not have either a depth/stencil or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the texel block size" }, { "vuid": "VUID-VkCopyImageToBufferInfo2-srcImage-07976", @@ -33079,13 +33631,25 @@ ] }, "vkCmdSetPrimitiveRestartEnable": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetPrimitiveRestartEnable-None-08500", + "text": " Either the extendedDynamicState2 feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetPrimitiveRestartEnable-None-08501", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetPrimitiveRestartEnable-None-04866", "text": " The extendedDynamicState2 feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetPrimitiveRestartEnable-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -33105,13 +33669,25 @@ ] }, "vkCmdSetPrimitiveTopology": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetPrimitiveTopology-None-08502", + "text": " Either the extendedDynamicState feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetPrimitiveTopology-None-08503", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetPrimitiveTopology-None-03347", "text": " The extendedDynamicState feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetPrimitiveTopology-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -33212,30 +33788,6 @@ "vuid": "VUID-vkCmdDraw-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" }, - { - "vuid": "VUID-vkCmdDraw-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDraw-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDraw-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDraw-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDraw-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDraw-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -33425,24 +33977,170 @@ "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" } ], - "!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDraw-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDraw-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDraw-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDraw-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDraw-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDraw-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDraw-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDraw-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" + }, + { + "vuid": "VUID-vkCmdDraw-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDraw-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDraw-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDraw-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDraw-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDraw-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" + }, + { + "vuid": "VUID-vkCmdDraw-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" + }, + { + "vuid": "VUID-vkCmdDraw-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDraw-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDraw-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDraw-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDraw-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDraw-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDraw-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDraw-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDraw-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "!(VK_EXT_descriptor_buffer)": [ + "(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDraw-None-02699", "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" } ], + "!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDraw-None-08114", @@ -33465,6 +34163,16 @@ "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" } ], + "(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-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" + }, + { + "vuid": "VUID-vkCmdDraw-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" + } + ], "!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDraw-None-02705", @@ -33485,21 +34193,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_VERSION_1_1)": [ + "(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDraw-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "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" - }, - { - "vuid": "VUID-vkCmdDraw-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" } ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDraw-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -33509,6 +34215,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDraw-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDraw-SampledType-04470", @@ -33589,6 +34305,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDraw-None-07840", @@ -33639,6 +34361,44 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDraw-viewportCount-04137", @@ -33649,6 +34409,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDraw-viewportCount-04139", @@ -33659,6 +34425,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDraw-VkPipelineVieportCreateInfo-04141", @@ -33679,6 +34451,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDraw-None-04876", @@ -33693,30 +34471,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDraw-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDraw-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDraw-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDraw-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDraw-imageView-06172", @@ -33789,6 +34601,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDraw-None-07751", @@ -33803,6 +34625,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDraw-imageView-06183", @@ -33877,15 +34709,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDraw-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDraw-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDraw-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -33921,7 +34749,297 @@ { "vuid": "VUID-vkCmdDraw-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDraw-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDraw-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDraw-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDraw-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDraw-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDraw-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDraw-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDraw-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDraw-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDraw-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDraw-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDraw-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDraw-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDraw-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDraw-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDraw-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDraw-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDraw-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDraw-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDraw-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -33951,41 +35069,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDraw-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDraw-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDraw-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDraw-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDraw-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDraw-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDraw-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDraw-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDraw-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDraw-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -34023,39 +35125,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDraw-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDraw-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDraw-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDraw-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDraw-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDraw-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDraw-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDraw-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDraw-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDraw-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDraw-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDraw-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDraw-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDraw-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDraw-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -34073,106 +35179,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDraw-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDraw-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDraw-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDraw-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDraw-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDraw-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDraw-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDraw-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDraw-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDraw-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDraw-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDraw-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDraw-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDraw-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDraw-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDraw-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDraw-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDraw-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDraw-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDraw-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDraw-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_EXT_mesh_shader)": [ @@ -34187,6 +35197,68 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDraw-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDraw-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDraw-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDraw-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDraw-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDraw-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDraw-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDraw-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDraw-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDraw-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDraw-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], + "(VK_VERSION_1_1)": [ + { + "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" + }, + { + "vuid": "VUID-vkCmdDraw-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" + } + ], "(VK_VERSION_1_1)+(VK_KHR_ray_query)": [ { "vuid": "VUID-vkCmdDraw-commandBuffer-04617", @@ -34262,30 +35334,6 @@ "vuid": "VUID-vkCmdDrawIndexed-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" }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -34483,24 +35531,170 @@ "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" } ], - "!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawIndexed-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-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" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-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" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-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" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexed-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "!(VK_EXT_descriptor_buffer)": [ + "(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexed-None-02699", "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" } ], + "!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawIndexed-None-08114", @@ -34523,6 +35717,16 @@ "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" } ], + "(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-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" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-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" + } + ], "!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawIndexed-None-02705", @@ -34543,21 +35747,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_VERSION_1_1)": [ + "(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "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" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-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" } ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexed-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -34567,6 +35769,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawIndexed-SampledType-04470", @@ -34647,6 +35859,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawIndexed-None-07840", @@ -34697,6 +35915,44 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawIndexed-viewportCount-04137", @@ -34707,6 +35963,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawIndexed-viewportCount-04139", @@ -34717,6 +35979,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawIndexed-VkPipelineVieportCreateInfo-04141", @@ -34737,6 +36005,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawIndexed-None-04876", @@ -34751,30 +36025,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawIndexed-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawIndexed-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawIndexed-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawIndexed-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawIndexed-imageView-06172", @@ -34847,6 +36155,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawIndexed-None-07751", @@ -34861,6 +36179,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawIndexed-imageView-06183", @@ -34935,15 +36263,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawIndexed-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawIndexed-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -34979,7 +36303,297 @@ { "vuid": "VUID-vkCmdDrawIndexed-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexed-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -35009,41 +36623,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawIndexed-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawIndexed-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawIndexed-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawIndexed-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -35081,39 +36679,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawIndexed-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndexed-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawIndexed-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawIndexed-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawIndexed-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawIndexed-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawIndexed-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndexed-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawIndexed-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndexed-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawIndexed-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawIndexed-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawIndexed-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -35131,106 +36733,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawIndexed-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawIndexed-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawIndexed-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawIndexed-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_EXT_mesh_shader)": [ @@ -35245,6 +36751,68 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawIndexed-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], + "(VK_VERSION_1_1)": [ + { + "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" + }, + { + "vuid": "VUID-vkCmdDrawIndexed-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" + } + ], "(VK_VERSION_1_1)+(VK_KHR_ray_query)": [ { "vuid": "VUID-vkCmdDrawIndexed-commandBuffer-04617", @@ -35320,30 +36888,6 @@ "vuid": "VUID-vkCmdDrawMultiEXT-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" }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -35549,24 +37093,170 @@ "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" } ], - "(VK_EXT_multi_draw)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_EXT_multi_draw)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawMultiEXT-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_EXT_multi_draw)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_EXT_multi_draw)+!(VK_EXT_descriptor_buffer)": [ + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_EXT_multi_draw)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-None-02699", "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" } ], + "(VK_EXT_multi_draw)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_EXT_multi_draw)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-None-08114", @@ -35589,6 +37279,16 @@ "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" } ], + "(VK_EXT_multi_draw)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-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" + } + ], "(VK_EXT_multi_draw)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-None-02705", @@ -35609,21 +37309,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_EXT_multi_draw)+(VK_VERSION_1_1)": [ + "(VK_EXT_multi_draw)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "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" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-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" } ], - "(VK_EXT_multi_draw)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_EXT_multi_draw)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -35633,6 +37331,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_EXT_multi_draw)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-SampledType-04470", @@ -35713,6 +37421,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_EXT_multi_draw)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-None-07840", @@ -35763,6 +37477,44 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called in the current command buffer prior to this drawing command" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-viewportCount-04137", @@ -35773,6 +37525,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-viewportCount-04139", @@ -35783,6 +37541,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-VkPipelineVieportCreateInfo-04141", @@ -35803,6 +37567,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-None-04876", @@ -35817,30 +37587,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_EXT_multi_draw)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_EXT_multi_draw)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_EXT_multi_draw)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_EXT_multi_draw)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_EXT_multi_draw)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_EXT_multi_draw)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-imageView-06172", @@ -35913,6 +37717,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-None-07751", @@ -35927,6 +37741,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-imageView-06183", @@ -36001,15 +37825,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawMultiEXT-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -36045,7 +37865,297 @@ { "vuid": "VUID-vkCmdDrawMultiEXT-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -36075,41 +38185,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMultiEXT-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -36147,39 +38241,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMultiEXT-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawMultiEXT-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawMultiEXT-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawMultiEXT-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawMultiEXT-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMultiEXT-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMultiEXT-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMultiEXT-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -36197,106 +38295,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawMultiEXT-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMultiEXT-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMultiEXT-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMultiEXT-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMultiEXT-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawMultiEXT-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_EXT_multi_draw)+(VK_EXT_mesh_shader)": [ @@ -36311,6 +38313,68 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_EXT_multi_draw)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawMultiEXT-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_1)": [ + { + "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" + }, + { + "vuid": "VUID-vkCmdDrawMultiEXT-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" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_1)+(VK_KHR_ray_query)": [ { "vuid": "VUID-vkCmdDrawMultiEXT-commandBuffer-04617", @@ -36386,30 +38450,6 @@ "vuid": "VUID-vkCmdDrawMultiIndexedEXT-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" }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -36627,24 +38667,170 @@ "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" } ], - "(VK_EXT_multi_draw)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_EXT_multi_draw)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_EXT_multi_draw)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_EXT_multi_draw)+!(VK_EXT_descriptor_buffer)": [ + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_EXT_multi_draw)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02699", "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" } ], + "(VK_EXT_multi_draw)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_EXT_multi_draw)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08114", @@ -36667,6 +38853,16 @@ "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" } ], + "(VK_EXT_multi_draw)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-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" + } + ], "(VK_EXT_multi_draw)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-02705", @@ -36687,21 +38883,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_EXT_multi_draw)+(VK_VERSION_1_1)": [ + "(VK_EXT_multi_draw)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "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" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-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" } ], - "(VK_EXT_multi_draw)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_EXT_multi_draw)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -36711,6 +38905,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_EXT_multi_draw)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-SampledType-04470", @@ -36791,6 +38995,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_EXT_multi_draw)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07840", @@ -36841,6 +39051,44 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called in the current command buffer prior to this drawing command" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewportCount-04137", @@ -36851,6 +39099,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewportCount-04139", @@ -36861,6 +39115,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-VkPipelineVieportCreateInfo-04141", @@ -36881,6 +39141,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-04876", @@ -36895,30 +39161,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_EXT_multi_draw)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_EXT_multi_draw)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_EXT_multi_draw)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_EXT_multi_draw)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_EXT_multi_draw)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_EXT_multi_draw)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-imageView-06172", @@ -36991,6 +39291,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07751", @@ -37005,6 +39315,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-imageView-06183", @@ -37079,15 +39399,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -37123,7 +39439,297 @@ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -37153,41 +39759,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -37225,39 +39815,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -37275,106 +39869,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_multi_draw)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMultiIndexedEXT-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_EXT_multi_draw)+(VK_EXT_mesh_shader)": [ @@ -37389,6 +39887,68 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_EXT_multi_draw)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_EXT_multi_draw)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], + "(VK_EXT_multi_draw)+(VK_VERSION_1_1)": [ + { + "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" + }, + { + "vuid": "VUID-vkCmdDrawMultiIndexedEXT-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" + } + ], "(VK_EXT_multi_draw)+(VK_VERSION_1_1)+(VK_KHR_ray_query)": [ { "vuid": "VUID-vkCmdDrawMultiIndexedEXT-commandBuffer-04617", @@ -37464,30 +40024,6 @@ "vuid": "VUID-vkCmdDrawIndirect-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" }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -37717,24 +40253,170 @@ "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" } ], - "!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawIndirect-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-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" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-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" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-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" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirect-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "!(VK_EXT_descriptor_buffer)": [ + "(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirect-None-02699", "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" } ], + "!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawIndirect-None-08114", @@ -37757,6 +40439,16 @@ "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" } ], + "(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-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" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-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" + } + ], "!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawIndirect-None-02705", @@ -37777,17 +40469,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_VERSION_1_1)": [ + "(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-02711", - "text": " commandBuffer must not be a protected command buffer" } ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirect-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -37797,6 +40491,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawIndirect-SampledType-04470", @@ -37877,6 +40581,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawIndirect-None-07840", @@ -37927,6 +40637,44 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawIndirect-viewportCount-04137", @@ -37937,6 +40685,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawIndirect-viewportCount-04139", @@ -37947,6 +40701,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawIndirect-VkPipelineVieportCreateInfo-04141", @@ -37967,6 +40727,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawIndirect-None-04876", @@ -37981,30 +40747,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawIndirect-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawIndirect-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawIndirect-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawIndirect-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawIndirect-imageView-06172", @@ -38077,6 +40877,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawIndirect-None-07751", @@ -38091,6 +40901,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawIndirect-imageView-06183", @@ -38165,15 +40985,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawIndirect-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawIndirect-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -38209,7 +41025,297 @@ { "vuid": "VUID-vkCmdDrawIndirect-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirect-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -38239,41 +41345,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawIndirect-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawIndirect-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawIndirect-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawIndirect-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -38311,39 +41401,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawIndirect-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndirect-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawIndirect-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawIndirect-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawIndirect-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawIndirect-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawIndirect-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndirect-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawIndirect-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndirect-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawIndirect-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawIndirect-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawIndirect-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -38361,106 +41455,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawIndirect-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawIndirect-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawIndirect-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawIndirect-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_EXT_mesh_shader)": [ @@ -38475,6 +41473,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndirect-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawIndirect-primitiveTopology-03420", @@ -38524,6 +41574,12 @@ "vuid": "VUID-vkCmdDrawIndirect-stage-06481", "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_EXT or VK_SHADER_STAGE_MESH_BIT_EXT" } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndirect-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } ] }, "VkDrawIndirectCommand": { @@ -38556,30 +41612,6 @@ "vuid": "VUID-vkCmdDrawIndirectCount-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" }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -38829,24 +41861,170 @@ "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" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawIndirectCount-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-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" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-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" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-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" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_descriptor_buffer)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-None-02699", "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" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-None-08114", @@ -38869,6 +42047,16 @@ "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" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-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" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-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" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-None-02705", @@ -38889,17 +42077,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-commandBuffer-02711", - "text": " commandBuffer must not be a protected command buffer" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -38909,6 +42099,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-SampledType-04470", @@ -38989,6 +42189,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-None-07840", @@ -39039,6 +42245,44 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-viewportCount-04137", @@ -39049,6 +42293,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-viewportCount-04139", @@ -39059,6 +42309,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-VkPipelineVieportCreateInfo-04141", @@ -39079,6 +42335,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-None-04876", @@ -39093,30 +42355,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-imageView-06172", @@ -39189,6 +42485,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-None-07751", @@ -39203,6 +42509,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-imageView-06183", @@ -39277,15 +42593,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawIndirectCount-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -39321,7 +42633,297 @@ { "vuid": "VUID-vkCmdDrawIndirectCount-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -39351,41 +42953,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawIndirectCount-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -39423,39 +43009,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndirectCount-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawIndirectCount-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawIndirectCount-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawIndirectCount-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawIndirectCount-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndirectCount-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndirectCount-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawIndirectCount-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -39473,106 +43063,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawIndirectCount-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCount-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCount-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCount-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawIndirectCount-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawIndirectCount-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_mesh_shader)": [ @@ -39587,6 +43081,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndirectCount-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-primitiveTopology-03420", @@ -39637,6 +43183,12 @@ "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_EXT or VK_SHADER_STAGE_MESH_BIT_EXT" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndirectCount-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_2)": [ { "vuid": "VUID-vkCmdDrawIndirectCount-None-04445", @@ -39662,30 +43214,6 @@ "vuid": "VUID-vkCmdDrawIndexedIndirect-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" }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -39923,24 +43451,170 @@ "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" } ], - "!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-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" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-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" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-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" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "!(VK_EXT_descriptor_buffer)": [ + "(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02699", "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" } ], + "!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08114", @@ -39963,6 +43637,16 @@ "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" } ], + "(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-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" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-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" + } + ], "!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-None-02705", @@ -39983,17 +43667,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_VERSION_1_1)": [ + "(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-02711", - "text": " commandBuffer must not be a protected command buffer" } ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -40003,6 +43689,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-SampledType-04470", @@ -40083,6 +43779,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07840", @@ -40133,6 +43835,44 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-viewportCount-04137", @@ -40143,6 +43883,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-viewportCount-04139", @@ -40153,6 +43899,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-VkPipelineVieportCreateInfo-04141", @@ -40173,6 +43925,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-None-04876", @@ -40187,30 +43945,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-imageView-06172", @@ -40283,6 +44075,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07751", @@ -40297,6 +44099,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-imageView-06183", @@ -40371,15 +44183,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -40415,7 +44223,297 @@ { "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -40445,41 +44543,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawIndexedIndirect-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -40517,39 +44599,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndexedIndirect-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawIndexedIndirect-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawIndexedIndirect-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawIndexedIndirect-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawIndexedIndirect-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndexedIndirect-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndexedIndirect-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawIndexedIndirect-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -40567,106 +44653,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirect-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawIndexedIndirect-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_EXT_mesh_shader)": [ @@ -40681,6 +44671,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirect-primitiveTopology-03420", @@ -40730,6 +44772,12 @@ "vuid": "VUID-vkCmdDrawIndexedIndirect-stage-06481", "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_EXT or VK_SHADER_STAGE_MESH_BIT_EXT" } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirect-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } ] }, "VkDrawIndexedIndirectCommand": { @@ -40762,30 +44810,6 @@ "vuid": "VUID-vkCmdDrawIndexedIndirectCount-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" }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -41043,24 +45067,170 @@ "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" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-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" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-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" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-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" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_descriptor_buffer)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02699", "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" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08114", @@ -41083,6 +45253,16 @@ "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" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-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" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-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" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-02705", @@ -41103,17 +45283,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02711", - "text": " commandBuffer must not be a protected command buffer" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -41123,6 +45305,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-SampledType-04470", @@ -41203,6 +45395,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07840", @@ -41253,6 +45451,44 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewportCount-04137", @@ -41263,6 +45499,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewportCount-04139", @@ -41273,6 +45515,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-VkPipelineVieportCreateInfo-04141", @@ -41293,6 +45541,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04876", @@ -41307,30 +45561,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-imageView-06172", @@ -41403,6 +45691,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07751", @@ -41417,6 +45715,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-imageView-06183", @@ -41491,15 +45799,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -41535,7 +45839,297 @@ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -41565,41 +46159,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -41637,39 +46215,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -41687,106 +46269,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawIndexedIndirectCount-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_mesh_shader)": [ @@ -41801,6 +46287,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-primitiveTopology-03420", @@ -41851,6 +46389,12 @@ "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_EXT or VK_SHADER_STAGE_MESH_BIT_EXT" } ], + "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } + ], "(VK_VERSION_1_2,VK_KHR_draw_indirect_count)+(VK_VERSION_1_2)": [ { "vuid": "VUID-vkCmdDrawIndexedIndirectCount-None-04445", @@ -41876,30 +46420,6 @@ "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-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" }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -42121,24 +46641,170 @@ "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" } ], - "(VK_EXT_transform_feedback)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_EXT_transform_feedback)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_EXT_transform_feedback)+!(VK_EXT_descriptor_buffer)": [ + "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_EXT_transform_feedback)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02699", "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" } ], + "(VK_EXT_transform_feedback)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_EXT_transform_feedback)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08114", @@ -42161,6 +46827,16 @@ "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" } ], + "(VK_EXT_transform_feedback)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-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" + } + ], "(VK_EXT_transform_feedback)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-02705", @@ -42181,17 +46857,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_EXT_transform_feedback)+(VK_VERSION_1_1)": [ + "(VK_EXT_transform_feedback)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-02646", - "text": " commandBuffer must not be a protected command buffer" } ], - "(VK_EXT_transform_feedback)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_EXT_transform_feedback)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -42201,6 +46879,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_EXT_transform_feedback)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-SampledType-04470", @@ -42281,6 +46969,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_EXT_transform_feedback)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07840", @@ -42331,6 +47025,44 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called in the current command buffer prior to this drawing command" } ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewportCount-04137", @@ -42341,6 +47073,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewportCount-04139", @@ -42351,6 +47089,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-VkPipelineVieportCreateInfo-04141", @@ -42371,6 +47115,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-04876", @@ -42385,30 +47135,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_EXT_transform_feedback)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_EXT_transform_feedback)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_EXT_transform_feedback)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_EXT_transform_feedback)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_EXT_transform_feedback)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_EXT_transform_feedback)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-imageView-06172", @@ -42481,6 +47265,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07751", @@ -42495,6 +47289,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-imageView-06183", @@ -42569,15 +47373,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -42613,7 +47413,297 @@ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -42643,41 +47733,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -42715,39 +47789,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -42765,106 +47843,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_EXT_transform_feedback)+(VK_EXT_mesh_shader)": [ @@ -42879,6 +47861,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_EXT_transform_feedback)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_EXT_transform_feedback)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-primitiveTopology-03420", @@ -42928,6 +47962,12 @@ "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-stage-06481", "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_EXT or VK_SHADER_STAGE_MESH_BIT_EXT" } + ], + "(VK_EXT_transform_feedback)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawIndirectByteCountEXT-commandBuffer-02646", + "text": " commandBuffer must not be a protected command buffer" + } ] }, "vkCmdBeginConditionalRenderingEXT": { @@ -43044,30 +48084,6 @@ "vuid": "VUID-vkCmdDrawMeshTasksNV-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" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -43253,24 +48269,170 @@ "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" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_descriptor_buffer)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02699", "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" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08114", @@ -43293,6 +48455,16 @@ "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" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-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" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-None-02705", @@ -43313,13 +48485,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -43329,6 +48507,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-SampledType-04470", @@ -43409,6 +48597,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07840", @@ -43455,6 +48649,44 @@ "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-viewportCount-04137", @@ -43465,6 +48697,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-viewportCount-04139", @@ -43475,6 +48713,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-VkPipelineVieportCreateInfo-04141", @@ -43495,6 +48739,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-None-04876", @@ -43505,30 +48755,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-imageView-06172", @@ -43601,6 +48885,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07751", @@ -43615,6 +48909,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-imageView-06183", @@ -43689,15 +48993,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -43733,7 +49033,297 @@ { "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -43763,41 +49353,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMeshTasksNV-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -43835,39 +49409,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksNV-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawMeshTasksNV-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawMeshTasksNV-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawMeshTasksNV-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawMeshTasksNV-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksNV-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksNV-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMeshTasksNV-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -43885,106 +49463,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksNV-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawMeshTasksNV-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_mesh_shader)": [ @@ -43999,6 +49481,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksNV-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_NV_mesh_shader,VK_EXT_mesh_shader)": [ { "vuid": "VUID-vkCmdDrawMeshTasksNV-stage-06480", @@ -44040,30 +49574,6 @@ "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-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" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -44285,24 +49795,170 @@ "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" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_descriptor_buffer)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02699", "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" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08114", @@ -44325,6 +49981,16 @@ "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" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-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" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-02705", @@ -44345,17 +50011,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02711", - "text": " commandBuffer must not be a protected command buffer" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -44365,6 +50033,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-SampledType-04470", @@ -44445,6 +50123,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07840", @@ -44491,6 +50175,44 @@ "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewportCount-04137", @@ -44501,6 +50223,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewportCount-04139", @@ -44511,6 +50239,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-VkPipelineVieportCreateInfo-04141", @@ -44531,6 +50265,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-04876", @@ -44541,30 +50281,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-imageView-06172", @@ -44637,6 +50411,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07751", @@ -44651,6 +50435,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-imageView-06183", @@ -44725,15 +50519,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -44769,7 +50559,297 @@ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -44799,41 +50879,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -44871,39 +50935,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -44921,106 +50989,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_mesh_shader)": [ @@ -45035,6 +51007,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_NV_mesh_shader,VK_EXT_mesh_shader)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-stage-06480", @@ -45056,6 +51080,12 @@ "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-None-07075", "text": " Primitives Generated Queries must not be active" } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } ] }, "VkDrawMeshTasksIndirectCommandNV": { @@ -45084,30 +51114,6 @@ "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-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" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -45349,24 +51355,170 @@ "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" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_descriptor_buffer)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02699", "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" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08114", @@ -45389,6 +51541,16 @@ "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" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-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" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02705", @@ -45409,17 +51571,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02711", - "text": " commandBuffer must not be a protected command buffer" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -45429,6 +51593,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-SampledType-04470", @@ -45509,6 +51683,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07840", @@ -45555,6 +51735,44 @@ "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewportCount-04137", @@ -45565,6 +51783,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewportCount-04139", @@ -45575,6 +51799,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-VkPipelineVieportCreateInfo-04141", @@ -45595,6 +51825,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-04876", @@ -45605,30 +51841,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-imageView-06172", @@ -45701,6 +51971,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07751", @@ -45715,6 +51995,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-imageView-06183", @@ -45789,15 +52079,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -45833,7 +52119,297 @@ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -45863,41 +52439,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -45935,39 +52495,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -45985,106 +52549,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_mesh_shader)": [ @@ -46099,6 +52567,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_NV_mesh_shader,VK_EXT_mesh_shader)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-stage-06480", @@ -46121,6 +52641,12 @@ "text": " Primitives Generated Queries must not be active" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_NV_mesh_shader)+(VK_VERSION_1_2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-04445", @@ -46146,30 +52672,6 @@ "vuid": "VUID-vkCmdDrawMeshTasksEXT-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" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -46383,24 +52885,170 @@ "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" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_descriptor_buffer)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02699", "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" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08114", @@ -46423,6 +53071,16 @@ "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" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-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" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-02705", @@ -46443,13 +53101,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -46459,6 +53123,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-SampledType-04470", @@ -46539,6 +53213,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07840", @@ -46585,6 +53265,44 @@ "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-viewportCount-04137", @@ -46595,6 +53313,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-viewportCount-04139", @@ -46605,6 +53329,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-VkPipelineVieportCreateInfo-04141", @@ -46625,6 +53355,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-04876", @@ -46635,30 +53371,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-imageView-06172", @@ -46731,6 +53501,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07751", @@ -46745,6 +53525,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-imageView-06183", @@ -46819,15 +53609,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -46863,7 +53649,297 @@ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -46893,41 +53969,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMeshTasksEXT-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -46965,39 +54025,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksEXT-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawMeshTasksEXT-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawMeshTasksEXT-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksEXT-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksEXT-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMeshTasksEXT-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -47015,106 +54079,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksEXT-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawMeshTasksEXT-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)": [ @@ -47129,6 +54097,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksEXT-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_NV_mesh_shader,VK_EXT_mesh_shader)": [ { "vuid": "VUID-vkCmdDrawMeshTasksEXT-stage-06480", @@ -47170,30 +54190,6 @@ "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-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" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -47415,24 +54411,170 @@ "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" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_descriptor_buffer)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02699", "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" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08114", @@ -47455,6 +54597,16 @@ "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" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-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" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-02705", @@ -47475,17 +54627,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-commandBuffer-02711", - "text": " commandBuffer must not be a protected command buffer" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -47495,6 +54649,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-SampledType-04470", @@ -47575,6 +54739,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07840", @@ -47621,6 +54791,44 @@ "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-viewportCount-04137", @@ -47631,6 +54839,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-viewportCount-04139", @@ -47641,6 +54855,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-VkPipelineVieportCreateInfo-04141", @@ -47661,6 +54881,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-04876", @@ -47671,30 +54897,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-imageView-06172", @@ -47767,6 +55027,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07751", @@ -47781,6 +55051,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-imageView-06183", @@ -47855,15 +55135,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -47899,7 +55175,297 @@ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -47929,41 +55495,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -48001,39 +55551,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -48051,106 +55605,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)": [ @@ -48165,6 +55623,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_NV_mesh_shader,VK_EXT_mesh_shader)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-stage-06480", @@ -48186,6 +55696,12 @@ "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-None-07075", "text": " Primitives Generated Queries must not be active" } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectEXT-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } ] }, "VkDrawMeshTasksIndirectCommandEXT": { @@ -48242,30 +55758,6 @@ "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-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" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -48507,24 +55999,170 @@ "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" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_descriptor_buffer)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02699", "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" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08114", @@ -48547,6 +56185,16 @@ "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" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-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" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-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" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-02705", @@ -48567,17 +56215,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-commandBuffer-02711", - "text": " commandBuffer must not be a protected command buffer" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -48587,6 +56237,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-SampledType-04470", @@ -48667,6 +56327,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07840", @@ -48713,6 +56379,44 @@ "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-viewportCount-04137", @@ -48723,6 +56427,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-viewportCount-04139", @@ -48733,6 +56443,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-VkPipelineVieportCreateInfo-04141", @@ -48753,6 +56469,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-04876", @@ -48763,30 +56485,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-imageView-06172", @@ -48859,6 +56615,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07751", @@ -48873,6 +56639,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-imageView-06183", @@ -48947,15 +56723,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -48991,7 +56763,297 @@ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -49021,41 +57083,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -49093,39 +57139,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -49143,106 +57193,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)": [ @@ -49257,6 +57211,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_NV_mesh_shader,VK_EXT_mesh_shader)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-stage-06480", @@ -49279,6 +57285,12 @@ "text": " Primitives Generated Queries must not be active" } ], + "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } + ], "(VK_NV_mesh_shader,VK_EXT_mesh_shader)+(VK_EXT_mesh_shader)+(VK_VERSION_1_2)": [ { "vuid": "VUID-vkCmdDrawMeshTasksIndirectCountEXT-None-04445", @@ -49304,30 +57316,6 @@ "vuid": "VUID-vkCmdDrawClusterHUAWEI-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" }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -49521,24 +57509,170 @@ "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" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-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" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-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" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-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" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_descriptor_buffer)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02699", "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" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08114", @@ -49561,6 +57695,16 @@ "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" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-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" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-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" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-02705", @@ -49581,13 +57725,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_1)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -49597,6 +57747,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-SampledType-04470", @@ -49677,6 +57837,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07840", @@ -49723,6 +57889,44 @@ "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-viewportCount-04137", @@ -49733,6 +57937,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-viewportCount-04139", @@ -49743,6 +57953,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-VkPipelineVieportCreateInfo-04141", @@ -49763,6 +57979,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-04876", @@ -49773,30 +57995,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-imageView-06172", @@ -49869,6 +58125,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07751", @@ -49883,6 +58149,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-imageView-06183", @@ -49957,15 +58233,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -50001,7 +58273,297 @@ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -50031,41 +58593,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawClusterHUAWEI-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -50103,39 +58649,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawClusterHUAWEI-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawClusterHUAWEI-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawClusterHUAWEI-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawClusterHUAWEI-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawClusterHUAWEI-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawClusterHUAWEI-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -50153,106 +58703,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawClusterHUAWEI-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawClusterHUAWEI-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_mesh_shader)": [ @@ -50267,6 +58721,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawClusterHUAWEI-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_NV_mesh_shader,VK_EXT_mesh_shader)": [ { "vuid": "VUID-vkCmdDrawClusterHUAWEI-stage-06480", @@ -50312,30 +58818,6 @@ "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-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" }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -50537,24 +59019,170 @@ "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" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-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" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-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" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-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" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_descriptor_buffer)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02699", "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" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08114", @@ -50577,6 +59205,16 @@ "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" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-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" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-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" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-02705", @@ -50597,13 +59235,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_1)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -50613,6 +59257,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-SampledType-04470", @@ -50693,6 +59347,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07840", @@ -50739,6 +59399,44 @@ "text": " If the bound graphics pipeline state was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-viewportCount-04137", @@ -50749,6 +59447,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-viewportCount-04139", @@ -50759,6 +59463,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-VkPipelineVieportCreateInfo-04141", @@ -50779,6 +59489,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-04876", @@ -50789,30 +59505,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-imageView-06172", @@ -50885,6 +59635,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07751", @@ -50899,6 +59659,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-imageView-06183", @@ -50973,15 +59743,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -51017,7 +59783,297 @@ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -51047,41 +60103,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -51119,39 +60159,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -51169,106 +60213,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_mesh_shader)": [ @@ -51283,6 +60231,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_HUAWEI_cluster_culling_shader)+(VK_HUAWEI_cluster_culling_shader)+(VK_NV_mesh_shader,VK_EXT_mesh_shader)": [ { "vuid": "VUID-vkCmdDrawClusterIndirectHUAWEI-stage-06480", @@ -51407,11 +60407,25 @@ ] }, "vkCmdSetVertexInputEXT": { - "(VK_EXT_vertex_input_dynamic_state)": [ + "(VK_EXT_vertex_input_dynamic_state,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetVertexInputEXT-None-08546", + "text": " Either the vertexInputDynamicState feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_vertex_input_dynamic_state,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_vertex_input_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetVertexInputEXT-None-08547", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_vertex_input_dynamic_state,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetVertexInputEXT-None-04790", "text": " The vertexInputDynamicState feature must be enabled" - }, + } + ], + "(VK_EXT_vertex_input_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetVertexInputEXT-vertexBindingDescriptionCount-04791", "text": " vertexBindingDescriptionCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings" @@ -51459,7 +60473,7 @@ ] }, "VkVertexInputBindingDescription2EXT": { - "(VK_EXT_vertex_input_dynamic_state)": [ + "(VK_EXT_vertex_input_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-VkVertexInputBindingDescription2EXT-binding-04796", "text": " binding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" @@ -51495,7 +60509,7 @@ ] }, "VkVertexInputAttributeDescription2EXT": { - "(VK_EXT_vertex_input_dynamic_state)": [ + "(VK_EXT_vertex_input_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-VkVertexInputAttributeDescription2EXT-location-06228", "text": " location must be less than VkPhysicalDeviceLimits::maxVertexInputAttributes" @@ -51521,7 +60535,7 @@ "text": " format must be a valid VkFormat value" } ], - "(VK_EXT_vertex_input_dynamic_state)+(VK_KHR_portability_subset)": [ + "(VK_EXT_vertex_input_dynamic_state,VK_EXT_shader_object)+(VK_KHR_portability_subset)": [ { "vuid": "VUID-VkVertexInputAttributeDescription2EXT-vertexAttributeAccessBeyondStride-04806", "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::vertexAttributeAccessBeyondStride is VK_FALSE, the sum of offset plus the size of the vertex attribute data described by format must not be greater than stride in the VkVertexInputBindingDescription2EXT referenced in binding" @@ -51595,7 +60609,7 @@ ] }, "vkCmdBindVertexBuffers2": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdBindVertexBuffers2-firstBinding-03355", "text": " firstBinding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings" @@ -51673,7 +60687,7 @@ "text": " Both of commandBuffer, and the elements of pBuffers that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_robustness2)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+(VK_EXT_robustness2)": [ { "vuid": "VUID-vkCmdBindVertexBuffers2-pBuffers-04112", "text": " If an element of pBuffers is VK_NULL_HANDLE, then the corresponding element of pOffsets must be zero" @@ -51757,11 +60771,25 @@ ] }, "vkCmdSetTessellationDomainOriginEXT": { - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetTessellationDomainOriginEXT-None-08576", + "text": " Either the extendedDynamicState3TessellationDomainOrigin feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetTessellationDomainOriginEXT-None-08577", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetTessellationDomainOriginEXT-extendedDynamicState3TessellationDomainOrigin-07444", "text": " The extendedDynamicState3TessellationDomainOrigin feature must be enabled" - }, + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetTessellationDomainOriginEXT-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -52031,11 +61059,25 @@ ] }, "vkCmdSetViewportSwizzleNV": { - "(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetViewportSwizzleNV-None-08578", + "text": " Either the extendedDynamicState3ViewportSwizzle feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetViewportSwizzleNV-None-08579", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetViewportSwizzleNV-extendedDynamicState3ViewportSwizzle-07445", "text": " The extendedDynamicState3ViewportSwizzle feature must be enabled" - }, + } + ], + "(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetViewportSwizzleNV-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -52099,11 +61141,25 @@ ] }, "vkCmdSetProvokingVertexModeEXT": { - "(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetProvokingVertexModeEXT-None-08580", + "text": " Either the extendedDynamicState3ProvokingVertexMode feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetProvokingVertexModeEXT-None-08581", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetProvokingVertexModeEXT-extendedDynamicState3ProvokingVertexMode-07446", "text": " The extendedDynamicState3ProvokingVertexMode feature must be enabled" - }, + } + ], + "(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetProvokingVertexModeEXT-provokingVertexMode-07447", "text": " If provokingVertexMode is VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT, then the provokingVertexLast feature must be enabled" @@ -52131,11 +61187,25 @@ ] }, "vkCmdSetDepthClampEnableEXT": { - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetDepthClampEnableEXT-None-08582", + "text": " Either the extendedDynamicState3DepthClampEnable feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetDepthClampEnableEXT-None-08583", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthClampEnableEXT-extendedDynamicState3DepthClampEnable-07448", "text": " The extendedDynamicState3DepthClampEnable feature must be enabled" - }, + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthClampEnableEXT-depthClamp-07449", "text": " If the depthClamp feature is not enabled, depthClampEnable must be VK_FALSE" @@ -52159,11 +61229,25 @@ ] }, "vkCmdSetDepthClipEnableEXT": { - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetDepthClipEnableEXT-None-08584", + "text": " Either the extendedDynamicState3DepthClipEnable feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetDepthClipEnableEXT-None-08585", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthClipEnableEXT-extendedDynamicState3DepthClipEnable-07450", "text": " The extendedDynamicState3DepthClipEnable feature must be enabled" - }, + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)": [ { "vuid": "VUID-vkCmdSetDepthClipEnableEXT-depthClipEnable-07451", "text": " The depthClipEnable feature must be enabled" @@ -52199,11 +61283,25 @@ ] }, "vkCmdSetDepthClipNegativeOneToOneEXT": { - "(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetDepthClipNegativeOneToOneEXT-None-08586", + "text": " Either the extendedDynamicState3DepthClipNegativeOneToOne feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetDepthClipNegativeOneToOneEXT-None-08587", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthClipNegativeOneToOneEXT-extendedDynamicState3DepthClipNegativeOneToOne-07452", "text": " The extendedDynamicState3DepthClipNegativeOneToOne feature must be enabled" - }, + } + ], + "(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthClipNegativeOneToOneEXT-depthClipControl-07453", "text": " The depthClipControl feature must be enabled" @@ -52239,11 +61337,25 @@ ] }, "vkCmdSetViewportWScalingEnableNV": { - "(VK_NV_clip_space_w_scaling)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_clip_space_w_scaling)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetViewportWScalingEnableNV-None-08594", + "text": " Either the extendedDynamicState3ViewportWScalingEnable feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_NV_clip_space_w_scaling)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetViewportWScalingEnableNV-None-08595", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_NV_clip_space_w_scaling)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetViewportWScalingEnableNV-extendedDynamicState3ViewportWScalingEnable-07580", "text": " The extendedDynamicState3ViewportWScalingEnable feature must be enabled" - }, + } + ], + "(VK_NV_clip_space_w_scaling)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetViewportWScalingEnableNV-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -52377,13 +61489,25 @@ ] }, "vkCmdSetViewportWithCount": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetViewportWithCount-None-08588", + "text": " Either the extendedDynamicState feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetViewportWithCount-None-08589", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetViewportWithCount-None-03393", "text": " The extendedDynamicState feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetViewportWithCount-viewportCount-03394", "text": " viewportCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" @@ -52417,7 +61541,7 @@ "text": " viewportCount must be greater than 0" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_inherited_viewport_scissor)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+(VK_NV_inherited_viewport_scissor)": [ { "vuid": "VUID-vkCmdSetViewportWithCount-commandBuffer-04819", "text": " commandBuffer must not have VkCommandBufferInheritanceViewportScissorInfoNV::viewportScissor2D enabled" @@ -52425,13 +61549,25 @@ ] }, "vkCmdSetScissorWithCount": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetScissorWithCount-None-08590", + "text": " Either the extendedDynamicState feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetScissorWithCount-None-08591", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetScissorWithCount-None-03396", "text": " The extendedDynamicState feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetScissorWithCount-scissorCount-03397", "text": " scissorCount must be between 1 and VkPhysicalDeviceLimits::maxViewports, inclusive" @@ -52477,7 +61613,7 @@ "text": " scissorCount must be greater than 0" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_inherited_viewport_scissor)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+(VK_NV_inherited_viewport_scissor)": [ { "vuid": "VUID-vkCmdSetScissorWithCount-commandBuffer-04820", "text": " commandBuffer must not have VkCommandBufferInheritanceViewportScissorInfoNV::viewportScissor2D enabled" @@ -52713,13 +61849,25 @@ ] }, "vkCmdSetRasterizerDiscardEnable": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetRasterizerDiscardEnable-None-08548", + "text": " Either the extendedDynamicState2 feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetRasterizerDiscardEnable-None-08549", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetRasterizerDiscardEnable-None-04871", "text": " The extendedDynamicState2 feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetRasterizerDiscardEnable-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -52763,11 +61911,25 @@ ] }, "vkCmdSetRasterizationStreamEXT": { - "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetRasterizationStreamEXT-None-08550", + "text": " Either the extendedDynamicState3RasterizationStream feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetRasterizationStreamEXT-None-08551", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetRasterizationStreamEXT-extendedDynamicState3RasterizationStream-07410", "text": " The extendedDynamicState3RasterizationStream feature must be enabled" - }, + } + ], + "(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetRasterizationStreamEXT-transformFeedback-07411", "text": " The transformFeedback feature must be enabled" @@ -52811,11 +61973,25 @@ ] }, "vkCmdSetRasterizationSamplesEXT": { - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetRasterizationSamplesEXT-None-08552", + "text": " Either the extendedDynamicState3RasterizationSamples feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetRasterizationSamplesEXT-None-08553", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetRasterizationSamplesEXT-extendedDynamicState3RasterizationSamples-07414", "text": " The extendedDynamicState3RasterizationSamples feature must be enabled" - }, + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetRasterizationSamplesEXT-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -52871,11 +62047,25 @@ ] }, "vkCmdSetSampleLocationsEnableEXT": { - "(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetSampleLocationsEnableEXT-None-08554", + "text": " Either the extendedDynamicState3SampleLocationsEnable feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetSampleLocationsEnableEXT-None-08555", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetSampleLocationsEnableEXT-extendedDynamicState3SampleLocationsEnable-07415", "text": " The extendedDynamicState3SampleLocationsEnable feature must be enabled" - }, + } + ], + "(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetSampleLocationsEnableEXT-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -53179,11 +62369,25 @@ ] }, "vkCmdSetShadingRateImageEnableNV": { - "(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetShadingRateImageEnableNV-None-08556", + "text": " Either the extendedDynamicState3ShadingRateImageEnable feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetShadingRateImageEnableNV-None-08557", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetShadingRateImageEnableNV-extendedDynamicState3ShadingRateImageEnable-07416", "text": " The extendedDynamicState3ShadingRateImageEnable feature must be enabled" - }, + } + ], + "(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetShadingRateImageEnableNV-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -53415,11 +62619,25 @@ ] }, "vkCmdSetLineRasterizationModeEXT": { - "(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetLineRasterizationModeEXT-None-08558", + "text": " Either the extendedDynamicState3LineRasterizationMode feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetLineRasterizationModeEXT-None-08559", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetLineRasterizationModeEXT-extendedDynamicState3LineRasterizationMode-07417", "text": " The extendedDynamicState3LineRasterizationMode feature must be enabled" - }, + } + ], + "(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetLineRasterizationModeEXT-lineRasterizationMode-07418", "text": " If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the rectangularLines feature must be enabled" @@ -53455,11 +62673,25 @@ ] }, "vkCmdSetLineStippleEnableEXT": { - "(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetLineStippleEnableEXT-None-08560", + "text": " Either the extendedDynamicState3LineStippleEnable feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetLineStippleEnableEXT-None-08561", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetLineStippleEnableEXT-extendedDynamicState3LineStippleEnable-07421", "text": " The extendedDynamicState3LineStippleEnable feature must be enabled" - }, + } + ], + "(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetLineStippleEnableEXT-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -53527,13 +62759,25 @@ ] }, "vkCmdSetFrontFace": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetFrontFace-None-08562", + "text": " Either the extendedDynamicState feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetFrontFace-None-08563", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetFrontFace-None-03383", "text": " The extendedDynamicState feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetFrontFace-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -53557,13 +62801,25 @@ ] }, "vkCmdSetCullMode": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetCullMode-None-08564", + "text": " Either the extendedDynamicState feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetCullMode-None-08565", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCullMode-None-03384", "text": " The extendedDynamicState feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCullMode-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -53587,11 +62843,41 @@ ] }, "vkCmdSetPolygonModeEXT": { - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetPolygonModeEXT-None-08566", + "text": " Either the extendedDynamicState3PolygonMode feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetPolygonModeEXT-None-08567", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetPolygonModeEXT-extendedDynamicState3PolygonMode-07422", "text": " The extendedDynamicState3PolygonMode feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_NV_fill_rectangle)": [ + { + "vuid": "VUID-vkCmdSetPolygonModeEXT-fillModeNonSolid-07423", + "text": " If the fillModeNonSolid feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fill_rectangle)": [ + { + "vuid": "VUID-vkCmdSetPolygonModeEXT-fillModeNonSolid-07424", + "text": " If the fillModeNonSolid feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL or VK_POLYGON_MODE_FILL_RECTANGLE_NV" }, + { + "vuid": "VUID-vkCmdSetPolygonModeEXT-polygonMode-07425", + "text": " If the VK_NV_fill_rectangle extension is not enabled, polygonMode must not be VK_POLYGON_MODE_FILL_RECTANGLE_NV" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetPolygonModeEXT-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -53612,32 +62898,28 @@ "vuid": "VUID-vkCmdSetPolygonModeEXT-videocoding", "text": " This command must only be called outside of a video coding scope" } - ], - "(VK_EXT_extended_dynamic_state3)+!(VK_NV_fill_rectangle)": [ - { - "vuid": "VUID-vkCmdSetPolygonModeEXT-fillModeNonSolid-07423", - "text": " If the fillModeNonSolid feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL" - } - ], - "(VK_EXT_extended_dynamic_state3)+(VK_NV_fill_rectangle)": [ - { - "vuid": "VUID-vkCmdSetPolygonModeEXT-fillModeNonSolid-07424", - "text": " If the fillModeNonSolid feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL or VK_POLYGON_MODE_FILL_RECTANGLE_NV" - }, - { - "vuid": "VUID-vkCmdSetPolygonModeEXT-polygonMode-07425", - "text": " If the VK_NV_fill_rectangle extension is not enabled, polygonMode must not be VK_POLYGON_MODE_FILL_RECTANGLE_NV" - } ] }, "vkCmdSetDepthBiasEnable": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetDepthBiasEnable-None-08568", + "text": " Either the extendedDynamicState2 feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetDepthBiasEnable-None-08569", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthBiasEnable-None-04872", "text": " The extendedDynamicState2 feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthBiasEnable-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -53701,11 +62983,25 @@ ] }, "vkCmdSetConservativeRasterizationModeEXT": { - "(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetConservativeRasterizationModeEXT-None-08570", + "text": " Either the extendedDynamicState3ConservativeRasterizationMode feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetConservativeRasterizationModeEXT-None-08571", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetConservativeRasterizationModeEXT-extendedDynamicState3ConservativeRasterizationMode-07426", "text": " The extendedDynamicState3ConservativeRasterizationMode feature must be enabled" - }, + } + ], + "(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetConservativeRasterizationModeEXT-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -53729,11 +63025,25 @@ ] }, "vkCmdSetExtraPrimitiveOverestimationSizeEXT": { - "(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetExtraPrimitiveOverestimationSizeEXT-None-08572", + "text": " Either the extendedDynamicState3ExtraPrimitiveOverestimationSize feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetExtraPrimitiveOverestimationSizeEXT-None-08573", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetExtraPrimitiveOverestimationSizeEXT-extendedDynamicState3ExtraPrimitiveOverestimationSize-07427", "text": " The extendedDynamicState3ExtraPrimitiveOverestimationSize feature must be enabled" - }, + } + ], + "(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetExtraPrimitiveOverestimationSizeEXT-extraPrimitiveOverestimationSize-07428", "text": " extraPrimitiveOverestimationSize must be in the range of 0.0 to VkPhysicalDeviceConservativeRasterizationPropertiesEXT::maxExtraPrimitiveOverestimationSize inclusive" @@ -54045,11 +63355,25 @@ ] }, "vkCmdSetSampleMaskEXT": { - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetSampleMaskEXT-None-08504", + "text": " Either the extendedDynamicState3SampleMask feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetSampleMaskEXT-None-08505", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetSampleMaskEXT-extendedDynamicState3SampleMask-07342", "text": " The extendedDynamicState3SampleMask feature must be enabled" - }, + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetSampleMaskEXT-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54077,11 +63401,25 @@ ] }, "vkCmdSetAlphaToCoverageEnableEXT": { - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetAlphaToCoverageEnableEXT-None-08506", + "text": " Either the <features-extendedDynamicState3AlphaToCoverageEnable, extendedDynamicState3AlphaToCoverageEnable>> feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetAlphaToCoverageEnableEXT-None-08507", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetAlphaToCoverageEnableEXT-extendedDynamicState3AlphaToCoverageEnable-07343", "text": " The extendedDynamicState3AlphaToCoverageEnable feature must be enabled" - }, + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetAlphaToCoverageEnableEXT-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54101,11 +63439,25 @@ ] }, "vkCmdSetAlphaToOneEnableEXT": { - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetAlphaToOneEnableEXT-None-08508", + "text": " Either the extendedDynamicState3AlphaToOneEnable feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetAlphaToOneEnableEXT-None-08509", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetAlphaToOneEnableEXT-extendedDynamicState3AlphaToOneEnable-07345", "text": " The extendedDynamicState3AlphaToOneEnable feature must be enabled" - }, + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetAlphaToOneEnableEXT-alphaToOne-07607", "text": " If the alphaToOne feature is not enabled, alphaToOneEnable must be VK_FALSE" @@ -54177,13 +63529,25 @@ ] }, "vkCmdSetDepthBoundsTestEnable": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetDepthBoundsTestEnable-None-08510", + "text": " Either the extendedDynamicState feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetDepthBoundsTestEnable-None-08511", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthBoundsTestEnable-None-03349", "text": " The extendedDynamicState feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthBoundsTestEnable-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54243,13 +63607,25 @@ ] }, "vkCmdSetStencilTestEnable": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetStencilTestEnable-None-08512", + "text": " Either the extendedDynamicState feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetStencilTestEnable-None-08513", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetStencilTestEnable-None-03350", "text": " The extendedDynamicState feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetStencilTestEnable-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54269,13 +63645,25 @@ ] }, "vkCmdSetStencilOp": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetStencilOp-None-08514", + "text": " Either the extendedDynamicState feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetStencilOp-None-08515", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetStencilOp-None-03351", "text": " The extendedDynamicState feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetStencilOp-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54423,13 +63811,25 @@ ] }, "vkCmdSetDepthTestEnable": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetDepthTestEnable-None-08516", + "text": " Either the extendedDynamicState feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetDepthTestEnable-None-08517", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthTestEnable-None-03352", "text": " The extendedDynamicState feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthTestEnable-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54449,13 +63849,25 @@ ] }, "vkCmdSetDepthCompareOp": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetDepthCompareOp-None-08518", + "text": " Either the extendedDynamicState feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetDepthCompareOp-None-08519", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthCompareOp-None-03353", "text": " The extendedDynamicState feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthCompareOp-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54479,13 +63891,25 @@ ] }, "vkCmdSetDepthWriteEnable": { - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_VERSION_1_3)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetDepthWriteEnable-None-08520", + "text": " Either the extendedDynamicState feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state)": [ + { + "vuid": "VUID-vkCmdSetDepthWriteEnable-None-08521", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)+!(VK_VERSION_1_3)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthWriteEnable-None-03354", "text": " The extendedDynamicState feature must be enabled" } ], - "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ + "(VK_VERSION_1_3,VK_EXT_extended_dynamic_state,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetDepthWriteEnable-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54513,11 +63937,25 @@ ] }, "vkCmdSetRepresentativeFragmentTestEnableNV": { - "(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetRepresentativeFragmentTestEnableNV-None-08522", + "text": " Either the extendedDynamicState3RepresentativeFragmentTestEnable feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetRepresentativeFragmentTestEnableNV-None-08523", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetRepresentativeFragmentTestEnableNV-extendedDynamicState3RepresentativeFragmentTestEnable-07346", "text": " The extendedDynamicState3RepresentativeFragmentTestEnable feature must be enabled" - }, + } + ], + "(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetRepresentativeFragmentTestEnableNV-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54553,11 +63991,25 @@ ] }, "vkCmdSetCoverageToColorEnableNV": { - "(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetCoverageToColorEnableNV-None-08524", + "text": " Either the extendedDynamicState3CoverageToColorEnable feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetCoverageToColorEnableNV-None-08525", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCoverageToColorEnableNV-extendedDynamicState3CoverageToColorEnable-07347", "text": " The extendedDynamicState3CoverageToColorEnable feature must be enabled" - }, + } + ], + "(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCoverageToColorEnableNV-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54577,11 +64029,25 @@ ] }, "vkCmdSetCoverageToColorLocationNV": { - "(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetCoverageToColorLocationNV-None-08526", + "text": " Either the extendedDynamicState3CoverageToColorLocation feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetCoverageToColorLocationNV-None-08527", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCoverageToColorLocationNV-extendedDynamicState3CoverageToColorLocation-07348", "text": " The extendedDynamicState3CoverageToColorLocation feature must be enabled" - }, + } + ], + "(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCoverageToColorLocationNV-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54617,11 +64083,25 @@ ] }, "vkCmdSetCoverageReductionModeNV": { - "(VK_NV_framebuffer_mixed_samples)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_framebuffer_mixed_samples)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetCoverageReductionModeNV-None-08528", + "text": " Either the extendedDynamicState3CoverageReductionMode feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_NV_framebuffer_mixed_samples)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetCoverageReductionModeNV-None-08529", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_NV_framebuffer_mixed_samples)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCoverageReductionModeNV-extendedDynamicState3CoverageReductionMode-07349", "text": " The extendedDynamicState3CoverageReductionMode feature must be enabled" - }, + } + ], + "(VK_NV_framebuffer_mixed_samples)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCoverageReductionModeNV-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54693,11 +64173,25 @@ ] }, "vkCmdSetCoverageModulationModeNV": { - "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetCoverageModulationModeNV-None-08530", + "text": " Either the extendedDynamicState3CoverageModulationMode feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetCoverageModulationModeNV-None-08531", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCoverageModulationModeNV-extendedDynamicState3CoverageModulationMode-07350", "text": " The extendedDynamicState3CoverageModulationMode feature must be enabled" - }, + } + ], + "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCoverageModulationModeNV-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54721,11 +64215,25 @@ ] }, "vkCmdSetCoverageModulationTableEnableNV": { - "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetCoverageModulationTableEnableNV-None-08532", + "text": " Either the extendedDynamicState3CoverageModulationTableEnable feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetCoverageModulationTableEnableNV-None-08533", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCoverageModulationTableEnableNV-extendedDynamicState3CoverageModulationTableEnable-07351", "text": " The extendedDynamicState3CoverageModulationTableEnable feature must be enabled" - }, + } + ], + "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCoverageModulationTableEnableNV-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54745,11 +64253,25 @@ ] }, "vkCmdSetCoverageModulationTableNV": { - "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetCoverageModulationTableNV-None-08534", + "text": " Either the extendedDynamicState3CoverageModulationTable feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetCoverageModulationTableNV-None-08535", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCoverageModulationTableNV-extendedDynamicState3CoverageModulationTable-07352", "text": " The extendedDynamicState3CoverageModulationTable feature must be enabled" - }, + } + ], + "(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetCoverageModulationTableNV-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54911,11 +64433,25 @@ ] }, "vkCmdSetColorBlendEnableEXT": { - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetColorBlendEnableEXT-None-08536", + "text": " Either the extendedDynamicState3ColorBlendEnable feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetColorBlendEnableEXT-None-08537", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetColorBlendEnableEXT-extendedDynamicState3ColorBlendEnable-07355", "text": " The extendedDynamicState3ColorBlendEnable feature must be enabled" - }, + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetColorBlendEnableEXT-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54943,11 +64479,25 @@ ] }, "vkCmdSetColorBlendEquationEXT": { - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetColorBlendEquationEXT-None-08538", + "text": " Either the extendedDynamicState3ColorBlendEquation feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetColorBlendEquationEXT-None-08539", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetColorBlendEquationEXT-extendedDynamicState3ColorBlendEquation-07356", "text": " The extendedDynamicState3ColorBlendEquation feature must be enabled" - }, + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetColorBlendEquationEXT-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -54975,7 +64525,7 @@ ] }, "VkColorBlendEquationEXT": { - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-VkColorBlendEquationEXT-dualSrcBlend-07357", "text": " If the dualSrcBlend feature is not enabled, srcColorBlendFactor must not be VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA" @@ -55017,13 +64567,13 @@ "text": " alphaBlendOp must be a valid VkBlendOp value" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ { "vuid": "VUID-VkColorBlendEquationEXT-colorBlendOp-07361", "text": " colorBlendOp and alphaBlendOp must not be VK_BLEND_OP_ZERO_EXT, VK_BLEND_OP_SRC_EXT, VK_BLEND_OP_DST_EXT, VK_BLEND_OP_SRC_OVER_EXT, VK_BLEND_OP_DST_OVER_EXT, VK_BLEND_OP_SRC_IN_EXT, VK_BLEND_OP_DST_IN_EXT, VK_BLEND_OP_SRC_OUT_EXT, VK_BLEND_OP_DST_OUT_EXT, VK_BLEND_OP_SRC_ATOP_EXT, VK_BLEND_OP_DST_ATOP_EXT, VK_BLEND_OP_XOR_EXT, VK_BLEND_OP_MULTIPLY_EXT, VK_BLEND_OP_SCREEN_EXT, VK_BLEND_OP_OVERLAY_EXT, VK_BLEND_OP_DARKEN_EXT, VK_BLEND_OP_LIGHTEN_EXT, VK_BLEND_OP_COLORDODGE_EXT, VK_BLEND_OP_COLORBURN_EXT, VK_BLEND_OP_HARDLIGHT_EXT, VK_BLEND_OP_SOFTLIGHT_EXT, VK_BLEND_OP_DIFFERENCE_EXT, VK_BLEND_OP_EXCLUSION_EXT, VK_BLEND_OP_INVERT_EXT, VK_BLEND_OP_INVERT_RGB_EXT, VK_BLEND_OP_LINEARDODGE_EXT, VK_BLEND_OP_LINEARBURN_EXT, VK_BLEND_OP_VIVIDLIGHT_EXT, VK_BLEND_OP_LINEARLIGHT_EXT, VK_BLEND_OP_PINLIGHT_EXT, VK_BLEND_OP_HARDMIX_EXT, VK_BLEND_OP_HSL_HUE_EXT, VK_BLEND_OP_HSL_SATURATION_EXT, VK_BLEND_OP_HSL_COLOR_EXT, VK_BLEND_OP_HSL_LUMINOSITY_EXT, VK_BLEND_OP_PLUS_EXT, VK_BLEND_OP_PLUS_CLAMPED_EXT, VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, VK_BLEND_OP_PLUS_DARKER_EXT, VK_BLEND_OP_MINUS_EXT, VK_BLEND_OP_MINUS_CLAMPED_EXT, VK_BLEND_OP_CONTRAST_EXT, VK_BLEND_OP_INVERT_OVG_EXT, VK_BLEND_OP_RED_EXT, VK_BLEND_OP_GREEN_EXT, or VK_BLEND_OP_BLUE_EXT" } ], - "(VK_EXT_extended_dynamic_state3)+(VK_KHR_portability_subset)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_KHR_portability_subset)": [ { "vuid": "VUID-VkColorBlendEquationEXT-constantAlphaColorBlendFactors-07362", "text": " If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::constantAlphaColorBlendFactors is VK_FALSE, srcColorBlendFactor must not be VK_BLEND_FACTOR_CONSTANT_ALPHA or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA" @@ -55035,11 +64585,25 @@ ] }, "vkCmdSetColorWriteMaskEXT": { - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetColorWriteMaskEXT-None-08540", + "text": " Either the extendedDynamicState3ColorWriteMask feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetColorWriteMaskEXT-None-08541", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetColorWriteMaskEXT-extendedDynamicState3ColorWriteMask-07364", "text": " The extendedDynamicState3ColorWriteMask feature must be enabled" - }, + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetColorWriteMaskEXT-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -55111,11 +64675,25 @@ ] }, "vkCmdSetColorBlendAdvancedEXT": { - "(VK_EXT_blend_operation_advanced)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_blend_operation_advanced)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetColorBlendAdvancedEXT-None-08592", + "text": " Either the extendedDynamicState3ColorBlendAdvanced feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_blend_operation_advanced)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetColorBlendAdvancedEXT-None-08593", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_blend_operation_advanced)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetColorBlendAdvancedEXT-extendedDynamicState3ColorBlendAdvanced-07504", "text": " The extendedDynamicState3ColorBlendAdvanced feature must be enabled" - }, + } + ], + "(VK_EXT_blend_operation_advanced)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetColorBlendAdvancedEXT-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -55143,7 +64721,7 @@ ] }, "VkColorBlendAdvancedEXT": { - "(VK_EXT_blend_operation_advanced)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_blend_operation_advanced)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-VkColorBlendAdvancedEXT-srcPremultiplied-07505", "text": " If the non-premultiplied source color property is not supported, srcPremultiplied must be VK_TRUE" @@ -55167,11 +64745,25 @@ ] }, "vkCmdSetLogicOpEnableEXT": { - "(VK_EXT_extended_dynamic_state3)": [ + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetLogicOpEnableEXT-None-08542", + "text": " Either the extendedDynamicState3LogicOpEnable feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdSetLogicOpEnableEXT-None-08543", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetLogicOpEnableEXT-extendedDynamicState3LogicOpEnable-07365", "text": " The extendedDynamicState3LogicOpEnable feature must be enabled" - }, + } + ], + "(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetLogicOpEnableEXT-logicOp-07366", "text": " If the logicOp feature is not enabled, logicOpEnable must be VK_FALSE" @@ -55195,11 +64787,25 @@ ] }, "vkCmdSetLogicOpEXT": { - "(VK_EXT_extended_dynamic_state2)": [ + "(VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+(VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetLogicOpEXT-None-08544", + "text": " Either the extendedDynamicState2LogicOp feature or the shaderObject feature or both must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+(VK_EXT_shader_object)+!(VK_EXT_extended_dynamic_state2)": [ + { + "vuid": "VUID-vkCmdSetLogicOpEXT-None-08545", + "text": " The shaderObject feature must be enabled" + } + ], + "(VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetLogicOpEXT-None-04867", "text": " The extendedDynamicState2LogicOp feature must be enabled" - }, + } + ], + "(VK_EXT_extended_dynamic_state2,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSetLogicOpEXT-commandBuffer-parameter", "text": " commandBuffer must be a valid VkCommandBuffer handle" @@ -55332,30 +64938,6 @@ "vuid": "VUID-vkCmdDispatch-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" }, - { - "vuid": "VUID-vkCmdDispatch-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDispatch-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDispatch-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDispatch-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDispatch-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDispatch-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -55465,24 +65047,102 @@ "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" } ], - "!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatch-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDispatch-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatch-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatch-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDispatch-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDispatch-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" + }, + { + "vuid": "VUID-vkCmdDispatch-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDispatch-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDispatch-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatch-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatch-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatch-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" + }, + { + "vuid": "VUID-vkCmdDispatch-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" + } + ], + "(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDispatch-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "!(VK_EXT_descriptor_buffer)": [ + "(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatch-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDispatch-None-02699", "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" } ], + "!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatch-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDispatch-None-08114", @@ -55505,6 +65165,16 @@ "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" } ], + "(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatch-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" + }, + { + "vuid": "VUID-vkCmdDispatch-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" + } + ], "!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDispatch-None-02705", @@ -55525,21 +65195,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_VERSION_1_1)": [ + "(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDispatch-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "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" - }, - { - "vuid": "VUID-vkCmdDispatch-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" } ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatch-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDispatch-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -55549,6 +65217,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatch-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDispatch-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDispatch-SampledType-04470", @@ -55609,6 +65287,16 @@ "text": " If any command other than OpImageWeightedSampleQCOM, OpImageBoxFilterQCOM, 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" } ], + "(VK_VERSION_1_1)": [ + { + "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" + }, + { + "vuid": "VUID-vkCmdDispatch-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" + } + ], "(VK_VERSION_1_1)+(VK_KHR_ray_query)": [ { "vuid": "VUID-vkCmdDispatch-commandBuffer-04617", @@ -55634,30 +65322,6 @@ "vuid": "VUID-vkCmdDispatchIndirect-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" }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -55779,24 +65443,102 @@ "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" } ], - "!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDispatchIndirect-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-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" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-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" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-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" + } + ], + "(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDispatchIndirect-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "!(VK_EXT_descriptor_buffer)": [ + "(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDispatchIndirect-None-02699", "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" } ], + "!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDispatchIndirect-None-08114", @@ -55819,6 +65561,16 @@ "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" } ], + "(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-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" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-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" + } + ], "!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDispatchIndirect-None-02705", @@ -55839,17 +65591,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_VERSION_1_1)": [ + "(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-02711", - "text": " commandBuffer must not be a protected command buffer" } ], - "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDispatchIndirect-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -55859,6 +65613,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDispatchIndirect-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDispatchIndirect-SampledType-04470", @@ -55918,6 +65682,12 @@ "vuid": "VUID-vkCmdDispatchIndirect-OpImageWeightedSampleQCOM-06978", "text": " If any command other than OpImageWeightedSampleQCOM, OpImageBoxFilterQCOM, 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" } + ], + "(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdDispatchIndirect-commandBuffer-02711", + "text": " commandBuffer must not be a protected command buffer" + } ] }, "VkDispatchIndirectCommand": { @@ -55954,30 +65724,6 @@ "vuid": "VUID-vkCmdDispatchBase-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" }, - { - "vuid": "VUID-vkCmdDispatchBase-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdDispatchBase-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdDispatchBase-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdDispatchBase-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDispatchBase-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdDispatchBase-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -56103,24 +65849,102 @@ "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" } ], - "(VK_VERSION_1_1,VK_KHR_device_group)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_VERSION_1_1,VK_KHR_device_group)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchBase-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdDispatchBase-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchBase-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdDispatchBase-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" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdDispatchBase-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchBase-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdDispatchBase-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" + }, + { + "vuid": "VUID-vkCmdDispatchBase-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" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDispatchBase-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_VERSION_1_1,VK_KHR_device_group)+!(VK_EXT_descriptor_buffer)": [ + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchBase-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDispatchBase-None-02699", "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" } ], + "(VK_VERSION_1_1,VK_KHR_device_group)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchBase-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdDispatchBase-None-08114", @@ -56143,6 +65967,16 @@ "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" } ], + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchBase-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" + }, + { + "vuid": "VUID-vkCmdDispatchBase-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" + } + ], "(VK_VERSION_1_1,VK_KHR_device_group)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdDispatchBase-None-02705", @@ -56163,21 +65997,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_1)": [ + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDispatchBase-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "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" - }, - { - "vuid": "VUID-vkCmdDispatchBase-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" } ], - "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchBase-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdDispatchBase-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -56187,6 +66019,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdDispatchBase-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdDispatchBase-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdDispatchBase-SampledType-04470", @@ -56247,6 +66089,16 @@ "text": " If any command other than OpImageWeightedSampleQCOM, OpImageBoxFilterQCOM, 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" } ], + "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_1)": [ + { + "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" + }, + { + "vuid": "VUID-vkCmdDispatchBase-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" + } + ], "(VK_VERSION_1_1,VK_KHR_device_group)+(VK_VERSION_1_1)+(VK_KHR_ray_query)": [ { "vuid": "VUID-vkCmdDispatchBase-commandBuffer-04617", @@ -56272,30 +66124,6 @@ "vuid": "VUID-vkCmdSubpassShadingHUAWEI-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" }, - { - "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -56397,24 +66225,102 @@ "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" } ], - "(VK_HUAWEI_subpass_shading)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_HUAWEI_subpass_shading)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_HUAWEI_subpass_shading)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_HUAWEI_subpass_shading)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-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" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-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" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-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" + } + ], + "(VK_HUAWEI_subpass_shading)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSubpassShadingHUAWEI-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_HUAWEI_subpass_shading)+!(VK_EXT_descriptor_buffer)": [ + "(VK_HUAWEI_subpass_shading)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_HUAWEI_subpass_shading)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02699", "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" } ], + "(VK_HUAWEI_subpass_shading)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_HUAWEI_subpass_shading)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-08114", @@ -56437,6 +66343,16 @@ "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" } ], + "(VK_HUAWEI_subpass_shading)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-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" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-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" + } + ], "(VK_HUAWEI_subpass_shading)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-02705", @@ -56457,13 +66373,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_HUAWEI_subpass_shading)+(VK_VERSION_1_1)": [ + "(VK_HUAWEI_subpass_shading)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSubpassShadingHUAWEI-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" } ], - "(VK_HUAWEI_subpass_shading)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_HUAWEI_subpass_shading)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_HUAWEI_subpass_shading)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -56473,6 +66395,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_HUAWEI_subpass_shading)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdSubpassShadingHUAWEI-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_HUAWEI_subpass_shading)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdSubpassShadingHUAWEI-SampledType-04470", @@ -56880,30 +66812,6 @@ "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-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" }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -57109,24 +67017,170 @@ "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" } ], - "(VK_NV_device_generated_commands)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_device_generated_commands)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_device_generated_commands)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-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" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-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" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-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" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08617", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08618", + "text": " If a shader object is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08619", + "text": " If a shader object that outputs line primitives is bound to the VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT or VK_SHADER_STAGE_GEOMETRY_BIT stage, vkCmdSetLineWidth must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08620", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBiasEnable in the current command buffer set depthBiasEnable to VK_TRUE, vkCmdSetDepthBias must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08621", + "text": " If a shader object is bound to the VK_SHADER_STAGE_FRAGMENT_BIT stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer set any element of pColorBlendEnables to VK_TRUE, and the most recent call to vkCmdSetColorBlendEquationEXT in the current command buffer set the same element of pColorBlendEquations to an VkColorBlendEquationEXT structure with any VkBlendFactor member with a value of VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, or VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, vkCmdSetBlendConstants must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08622", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthBoundsTestEnable in the current command buffer set depthBoundsTestEnable to VK_TRUE, vkCmdSetDepthBounds must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08623", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilCompareMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08624", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilWriteMask must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08625", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, vkCmdSetStencilReference must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08643", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then for each color attachment in the render pass, if the corresponding image view’s format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding member of pColorBlendEnables in the most recent call to vkCmdSetColorBlendEnableEXT in the current command buffer that affected that attachment index must have been VK_FALSE" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08684", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_VERTEX_BIT" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08685", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08686", + "text": " If there is no bound graphics pipeline, and the tessellationShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08687", + "text": " If there is no bound graphics pipeline, and the geometryShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_GEOMETRY_BIT" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08688", + "text": " If there is no bound graphics pipeline, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_FRAGMENT_BIT" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08698", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, then all shaders created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag in the same vkCreateShadersEXT call must also be bound" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08699", + "text": " If any graphics shader is bound which was created with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag, any stages in between stages whose shaders which did not create a shader with the VK_SHADER_CREATE_LINK_STAGE_BIT_EXT flag as part of the same vkCreateShadersEXT call must not have any VkShaderEXT bound" + } + ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_NV_device_generated_commands)+!(VK_EXT_descriptor_buffer)": [ + "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_device_generated_commands)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02699", "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" } ], + "(VK_NV_device_generated_commands)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_NV_device_generated_commands)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08114", @@ -57149,6 +67203,16 @@ "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" } ], + "(VK_NV_device_generated_commands)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-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" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-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" + } + ], "(VK_NV_device_generated_commands)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02705", @@ -57169,17 +67233,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_NV_device_generated_commands)+(VK_VERSION_1_1)": [ + "(VK_NV_device_generated_commands)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-02970", - "text": " commandBuffer must not be a protected command buffer" } ], - "(VK_NV_device_generated_commands)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_NV_device_generated_commands)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -57189,6 +67255,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_NV_device_generated_commands)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-SampledType-04470", @@ -57269,6 +67345,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" } ], + "(VK_NV_device_generated_commands)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08626", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetSampleLocationsEnableEXT in the current command buffer set sampleLocationsEnable to VK_TRUE, vkCmdSetSampleLocationsEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07840", @@ -57319,6 +67401,44 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08627", + "text": " If a shader object is bound to any graphics stage, vkCmdSetCullMode must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08628", + "text": " If a shader object is bound to any graphics stage, vkCmdSetFrontFace must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08629", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08630", + "text": " If a shader object is bound to any graphics stage, vkCmdSetDepthWriteEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08631", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetDepthTestEnable in the current command buffer set depthTestEnable to VK_TRUE, vkCmdSetDepthCompareOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08632", + "text": " If a shader object is bound to any graphics stage, and the depthBounds feature is enabled, the vkCmdSetDepthBoundsTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08633", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetStencilTestEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08634", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetStencilTestEnable in the current command buffer set stencilTestEnable to VK_TRUE, then vkCmdSetStencilOp must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08635", + "text": " If a shader object is bound to any graphics stage, then both vkCmdSetViewportWithCount and vkCmdSetScissorWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must match the scissorCount parameter of vkCmdSetScissorWithCount" + } + ], "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewportCount-04137", @@ -57329,6 +67449,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_clip_space_w_scaling)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08636", + "text": " If a shader object is bound to any graphics stage, and the VK_NV_clip_space_w_scaling extension is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportWScalingNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewportCount-04139", @@ -57339,6 +67465,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" } ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08637", + "text": " If a shader object is bound to any graphics stage, and the shadingRateImage feature is enabled on the device, then the viewportCount parameter in the last call to vkCmdSetViewportShadingRatePaletteNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_viewport_swizzle)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-VkPipelineVieportCreateInfo-04141", @@ -57359,6 +67491,12 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV dynamic state enabled then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_NV_scissor_exclusive)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08638", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetExclusiveScissorEnableNV in the current command buffer set any element of pExclusiveScissorEnables to VK_TRUE, then vkCmdSetExclusiveScissorNV must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-04876", @@ -57373,30 +67511,64 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08639", + "text": " If a shader object is bound to any graphics stage, then vkCmdSetRasterizerDiscardEnable must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08640", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthBiasEnable must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-logicOp-04878", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LOGIC_OP_EXT dynamic state enabled then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" } ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state2)+(VK_EXT_extended_dynamic_state2)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08641", + "text": " If a shader object is bound to any graphics stage, and the logicOp feature is enabled on the device, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEXT must have been called in the current command buffer prior to this drawing command and the logicOp must be a valid VkLogicOp value" + } + ], "(VK_NV_device_generated_commands)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-primitiveFragmentShadingRateWithMultipleViewports-04552", "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, and any of the shader stages of the bound graphics pipeline write to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" } ], + "(VK_NV_device_generated_commands)+(VK_KHR_fragment_shading_rate)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-primitiveFragmentShadingRateWithMultipleViewports-08642", + "text": " If the primitiveFragmentShadingRateWithMultipleViewports limit is not supported, and any shader object bound to a graphics stage writes to the PrimitiveShadingRateKHR built-in, then vkCmdSetViewportWithCount must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCount must be 1" + } + ], "(VK_NV_device_generated_commands)+(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-multisampledRenderToSingleSampled-07284", "text": " If rasterization is not disabled in the bound graphics pipeline, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_device_generated_commands)+(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08644", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and none of the VK_AMD_mixed_attachment_samples extension, the VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_device_generated_commands)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-rasterizationSamples-04740", "text": " If rasterization is not disabled in the bound graphics pipeline, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then rasterizationSamples for the currently bound graphics pipeline must be the same as the current subpass color and/or depth/stencil attachments" } ], + "(VK_NV_device_generated_commands)+!(VK_EXT_multisampled_render_to_single_sampled)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08645", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the most recent call to vkCmdSetRasterizationSamplesEXT in the current command buffer must have set rasterizationSamples to be the same as the number of samples for the current render pass color and/or depth/stencil attachments" + } + ], "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-imageView-06172", @@ -57469,6 +67641,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT dynamic state enabled then the attachmentCount parameter of vkCmdSetColorWriteEnableEXT must be greater than or equal to the VkPipelineColorBlendStateCreateInfo::attachmentCount of the currently bound graphics pipeline" } ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_color_write_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08646", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08647", + "text": " If the colorWriteEnable feature is enabled on the device, and a shader object is bound to the fragment stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then the attachmentCount parameter of most recent call to vkCmdSetColorWriteEnableEXT in the current command buffer must be greater than or equal to the number of color attachments in the current render pass instance" + } + ], "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07751", @@ -57483,6 +67665,16 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT dynamic state enabled then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" } ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_EXT_discard_rectangles)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08648", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDiscardRectangleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08649", + "text": " If the VK_EXT_discard_rectangles extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetDiscardRectangleEnableEXT in the current command buffer set discardRectangleEnable to VK_TRUE, then vkCmdSetDiscardRectangleModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_KHR_dynamic_rendering)+(VK_KHR_fragment_shading_rate)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-imageView-06183", @@ -57557,15 +67749,11 @@ "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, the bound graphics pipeline must not have been created with a non-zero value in VkPipelineRasterizationStateStreamCreateInfoEXT::rasterizationStream" } ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)": [ + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07619", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT dynamic state enabled then vkCmdSetTessellationDomainOriginEXT must have been called in the current command buffer prior to this drawing command" }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07620", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" - }, { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07621", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_POLYGON_MODE_EXT dynamic state enabled then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" @@ -57601,7 +67789,297 @@ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07629", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08650", + "text": " If the depthClamp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetDepthClampEnableEXT must have been called in the current command buffer prior to this drawing command" }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08651", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetPolygonModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08652", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetRasterizationSamplesEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08653", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleMaskEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08654", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToCoverageEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08655", + "text": " If the alphaToOne feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetAlphaToOneEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08656", + "text": " If the logicOp feature is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetLogicOpEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08657", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorBlendEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08658", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetColorBlendEnableEXT for any attachment set that attachment’s value in pColorBlendEnables to VK_TRUE, then vkCmdSetColorBlendEquationEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08659", + "text": " If a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07630", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08660", + "text": " If the geometryStreams feature is enabled, and a shader object is bound to the geometry stage, then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07631", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07632", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08661", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08662", + "text": " If the VK_EXT_conservative_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, and the most recent call to vkCmdSetConservativeRasterizationModeEXT in the current command buffer set conservativeRasterizationMode to VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT, then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07633", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_enable)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08663", + "text": " If the depthClipEnable feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07634", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08664", + "text": " If the VK_EXT_sample_locations extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetRasterizerDiscardEnable in the current command buffer set rasterizerDiscardEnable to VK_FALSE, then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_blend_operation_advanced)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07635", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-firstAttachment-07479", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-advancedBlendMaxColorAttachments-07480", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07636", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_provoking_vertex)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08665", + "text": " If the VK_EXT_provoking_vertex extension is enabled, and a shader object is bound to the vertex stage, then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07637", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07638", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07849", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08666", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08667", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08668", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08669", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetPolygonModeEXT in the current command buffer set polygonMode to VK_POLYGON_MODE_LINE, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08670", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to the vertex stage, and the most recent call to vkCmdSetPrimitiveTopology in the current command buffer set primitiveTopology to any line topology, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08671", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object that outputs line primitives is bound to the tessellation evaluation or geometry stage, then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08672", + "text": " If the VK_EXT_line_rasterization extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetLineStippleEnableEXT in the current command buffer set stippledLineEnable to VK_TRUE, then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07639", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_depth_clip_control)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08673", + "text": " If the depthClipControl feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07640", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command endif::VK_EXT_extended_dynamic_state3" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_clip_space_w_scaling[]\nifdef::VK_EXT_extended_dynamic_stat)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08674", + "text": " If the VK_NV_clip_space_w_scaling extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07641", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08675", + "text": " If the VK_NV_viewport_swizzle extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07642", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07643", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08676", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08677", + "text": " If the VK_NV_fragment_coverage_to_color extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageToColorEnableNV in the current command buffer set coverageToColorEnable to VK_TRUE, then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07644", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07645", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07646", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08678", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08679", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08680", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and a shader object is bound to any graphics stage, and the most recent call to vkCmdSetCoverageModulationTableEnableNV in the current command buffer set coverageModulationTableEnable to VK_TRUE, then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07647", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_shading_rate_image)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08681", + "text": " If the shadingRateImage feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07648", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_representative_fragment_test)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08682", + "text": " If the representativeFragmentTest feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_extended_dynamic_state3)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07649", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_coverage_reduction_mode)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08683", + "text": " If the coverageReductionMode feature is enabled, and a shader object is bound to any graphics stage, then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pColorBlendEnables-07470", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT state enabled and the last call to vkCmdSetColorBlendEnableEXT set pColorBlendEnables for any attachment to VK_TRUE, then for those attachments in the subpass the corresponding image view’s format features must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT" @@ -57631,41 +68109,25 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT dynamic state enabled then vkCmdSetColorWriteMaskEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorWriteMaskEXT calls must specify the color write mask for all active color attachments in the current subpass" } ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_transform_feedback)": [ + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+!(VK_EXT_multisampled_render_to_single_sampled)": [ { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07630", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT dynamic state enabled then vkCmdSetRasterizationStreamEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-rasterizationSamples-07474", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_multisampled_render_to_single_sampled)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-multisampledRenderToSingleSampled-07475", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-primitivesGeneratedQueryWithNonZeroStreams-07481", "text": " If the primitivesGeneratedQueryWithNonZeroStreams feature is not enabled and the VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT query is active, and the bound graphics pipeline was created with VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT state enabled, the last call to vkCmdSetRasterizationStreamEXT must have set the rasterizationStream to zero" } ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_conservative_rasterization)": [ - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07631", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetConservativeRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07632", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT dynamic state enabled then vkCmdSetExtraPrimitiveOverestimationSizeEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-conservativePointAndLineRasterization-07499", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" - } - ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_enable)": [ - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07633", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT dynamic state enabled then vkCmdSetDepthClipEnableEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_sample_locations)": [ - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07634", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT dynamic state enabled then vkCmdSetSampleLocationsEnableEXT must have been called in the current command buffer prior to this drawing command" - }, + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_sample_locations)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-sampleLocationsPerPixel-07482", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state enabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state disabled, then the sampleLocationsPerPixel member of pSampleLocationsInfo in the last call to vkCmdSetSampleLocationsEXT must equal the rasterizationSamples member of the VkPipelineMultisampleStateCreateInfo structure the bound graphics pipeline has been created with" @@ -57703,39 +68165,43 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT state disabled and the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable in the bound graphics pipeline is VK_TRUE or VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT state enabled, then, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT" } ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_blend_operation_advanced)": [ + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_framebuffer_mixed_samples)": [ { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07635", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-coverageModulationTableEnable-07488", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" }, { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-firstAttachment-07479", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT dynamic state enabled then vkCmdSetColorBlendAdvancedEXT must have been called in the current command buffer prior to this drawing command, and the attachments specified by the firstAttachment and attachmentCount parameters of vkCmdSetColorBlendAdvancedEXT calls must specify the advanced blend equations for all active color attachments in the current subpass where blending is enabled" + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-rasterizationSamples-07489", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" }, { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-advancedBlendMaxColorAttachments-07480", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT and VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic states enabled and the last calls to vkCmdSetColorBlendEnableEXT and vkCmdSetColorBlendAdvancedEXT have enabled advanced blending, then the number of active color attachments in the current subpass must not exceed advancedBlendMaxColorAttachments" + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-rasterizationSamples-07494", + "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" } ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_provoking_vertex)": [ + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)": [ { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07636", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT dynamic state enabled then vkCmdSetProvokingVertexModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-coverageToColorEnable-07490", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" } ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_line_rasterization)": [ + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07637", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic state enabled then vkCmdSetLineRasterizationModeEXT must have been called in the current command buffer prior to this drawing command" + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-coverageReductionMode-07491", + "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_NV_viewport_swizzle)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewportCount-07492", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" }, { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07638", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT dynamic state enabled then vkCmdSetLineStippleEnableEXT must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07849", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled then vkCmdSetLineStippleEXT must have been called in the current command buffer prior to this drawing command" - }, + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewportCount-07493", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_line_rasterization)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-stippledLineEnable-07495", "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled" @@ -57753,106 +68219,10 @@ "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT or VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT dynamic states enabled, and if the current stippledLineEnable state is VK_TRUE and the current lineRasterizationMode state is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE" } ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_depth_clip_control)": [ + "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3,VK_EXT_shader_object)+(VK_EXT_conservative_rasterization)": [ { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07639", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT dynamic state enabled then vkCmdSetDepthClipNegativeOneToOneEXT must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_NV_clip_space_w_scaling)": [ - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07640", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV dynamic state enabled then vkCmdSetViewportWScalingEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_NV_viewport_swizzle)": [ - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07641", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled then vkCmdSetViewportSwizzleNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewportCount-07492", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, but not the VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic state enabled, then the bound graphics pipeline must have been created with VkPipelineViewportSwizzleStateCreateInfoNV::viewportCount greater or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-viewportCount-07493", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV dynamic states enabled then the viewportCount parameter in the last call to vkCmdSetViewportSwizzleNV must be greater than or equal to the viewportCount parameter in the last call to vkCmdSetViewportWithCount" - } - ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)": [ - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07642", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV dynamic state enabled then vkCmdSetCoverageToColorEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07643", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV dynamic state enabled then vkCmdSetCoverageToColorLocationNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-coverageToColorEnable-07490", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV state enabled and the last call to vkCmdSetCoverageToColorEnableNV set the coverageToColorEnable to VK_TRUE, then the current subpass must have a color attachment at the location selected by the last call to vkCmdSetCoverageToColorLocationNV coverageToColorLocation, with a VkFormat of VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R32_UINT, or VK_FORMAT_R32_SINT" - } - ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_NV_framebuffer_mixed_samples)": [ - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07644", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV dynamic state enabled then vkCmdSetCoverageModulationModeNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07645", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableEnableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07646", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV dynamic state enabled then vkCmdSetCoverageModulationTableNV must have been called in the current command buffer prior to this drawing command" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-coverageModulationTableEnable-07488", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV state enabled and the last call to vkCmdSetCoverageModulationTableEnableNV set coverageModulationTableEnable to VK_TRUE, then the coverageModulationTableCount parameter in the last call to vkCmdSetCoverageModulationTableNV must equal the current rasterizationSamples divided by the number of color samples in the current subpass" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-rasterizationSamples-07489", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if current subpass has a depth/stencil attachment and depth test, stencil test, or depth bounds test are enabled in the currently bound pipeline state, then the current rasterizationSamples must be the same as the sample count of the depth/stencil attachment" - }, - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-rasterizationSamples-07494", - "text": " If the VK_NV_framebuffer_mixed_samples extension is enabled, and if the current subpass has any color attachments and rasterizationSamples of the last call to vkCmdSetRasterizationSamplesEXT is greater than the number of color samples, then the pipeline sampleShadingEnable must be VK_FALSE" - } - ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_NV_shading_rate_image)": [ - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07647", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV dynamic state enabled then vkCmdSetShadingRateImageEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_NV_representative_fragment_test)": [ - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07648", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV dynamic state enabled then vkCmdSetRepresentativeFragmentTestEnableNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-07649", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV dynamic state enabled then vkCmdSetCoverageReductionModeNV must have been called in the current command buffer prior to this drawing command" - } - ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+!(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-rasterizationSamples-07474", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_EXT_multisampled_render_to_single_sampled)": [ - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-multisampledRenderToSingleSampled-07475", - "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT state enabled, and none of the VK_AMD_mixed_attachment_samples extension, VK_NV_framebuffer_mixed_samples extension, or the multisampledRenderToSingleSampled feature is enabled, then the rasterizationSamples in the last call to vkCmdSetRasterizationSamplesEXT must be the same as the current subpass color and/or depth/stencil attachments" - } - ], - "(VK_NV_device_generated_commands)+(VK_EXT_extended_dynamic_state3)+(VK_NV_fragment_coverage_to_color)+(VK_NV_coverage_reduction_mode)": [ - { - "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-coverageReductionMode-07491", - "text": " If this VK_NV_coverage_reduction_mode extension is enabled, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV and VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT states enabled, the current coverage reduction mode coverageReductionMode, then the current rasterizationSamples, and the sample counts for the color and depth/stencil attachments (if the subpass has them) must be a valid combination returned by vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV" + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-conservativePointAndLineRasterization-07499", + "text": " If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT dynamic state enabled, conservativePointAndLineRasterization is not supported, and the effective primitive topology output by the last pre-rasterization shader stage is a line or point, then the conservativeRasterizationMode set by the last call to vkCmdSetConservativeRasterizationModeEXT must be VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT" } ], "(VK_NV_device_generated_commands)+(VK_EXT_mesh_shader)": [ @@ -57867,6 +68237,58 @@ "text": " If dynamic state was inherited from VkCommandBufferInheritanceViewportScissorInfoNV, it must be set in the current command buffer prior to this drawing command" } ], + "(VK_NV_device_generated_commands)+(VK_EXT_shader_object)+(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08689", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08690", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_EXT" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08693", + "text": " If there is no bound graphics pipeline, and at least one of the taskShader and meshShader features is enabled, one of the VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_EXT stages must have a valid VkShaderEXT bound, and the other must have no VkShaderEXT bound" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08694", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created without the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, a valid VkShaderEXT must be bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08695", + "text": " If there is no bound graphics pipeline, and both the taskShader and meshShader features are enabled, and a valid VkShaderEXT is bound the to the VK_SHADER_STAGE_MESH_BIT_EXT stage, and that VkShaderEXT was created with the VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT flag, there must be no VkShaderEXT bound to the VK_SHADER_STAGE_TASK_BIT_EXT stage" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08696", + "text": " If there is no bound graphics pipeline, and a valid VkShaderEXT is bound to the VK_SHADER_STAGE_VERTEX_BIT stage, there must be no VkShaderEXT bound to either the VK_SHADER_STAGE_TASK_BIT_EXT stage or the VK_SHADER_STAGE_MESH_BIT_EXT stage" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)+(VK_NV_mesh_shader)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08691", + "text": " If there is no bound graphics pipeline, and the taskShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_TASK_BIT_NV" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08692", + "text": " If there is no bound graphics pipeline, and the meshShader feature is enabled, vkCmdBindShadersEXT must have been called on the current command buffer with pStages with an element of VK_SHADER_STAGE_MESH_BIT_NV" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_shader_object)+!(VK_EXT_mesh_shader)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-08697", + "text": " If there is no bound graphics pipeline, a VkShaderEXT must be bound to the VK_SHADER_STAGE_VERTEX_BIT stage" + } + ], + "(VK_NV_device_generated_commands)+(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pDynamicStates-08715", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpDepthAttachmentReadEXT, the depthWriteEnable parameter in the last call to vkCmdSetDepthWriteEnable must be VK_FALSE" + }, + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-pDynamicStates-08716", + "text": " If the bound graphics pipeline state includes a fragment shader stage, was created with VK_DYNAMIC_STATE_STENCIL_WRITE_MASK set in VkPipelineDynamicStateCreateInfo::pDynamicStates, and the fragment shader declares the EarlyFragmentTests execution mode and uses OpStencilAttachmentReadEXT, the writeMask parameter in the last call to vkCmdSetStencilWriteMask must be 0" + } + ], "(VK_NV_device_generated_commands)+(VK_VERSION_1_3,VK_EXT_extended_dynamic_state)+!(VK_EXT_extended_dynamic_state3)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-primitiveTopology-03420", @@ -57917,6 +68339,12 @@ "text": " The bound graphics pipeline must not have been created with the VkPipelineShaderStageCreateInfo::stage member of an element of VkGraphicsPipelineCreateInfo::pStages set to VK_SHADER_STAGE_TASK_BIT_EXT or VK_SHADER_STAGE_MESH_BIT_EXT" } ], + "(VK_NV_device_generated_commands)+(VK_VERSION_1_1)": [ + { + "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-commandBuffer-02970", + "text": " commandBuffer must not be a protected command buffer" + } + ], "(VK_NV_device_generated_commands)+(VK_EXT_transform_feedback)": [ { "vuid": "VUID-vkCmdExecuteGeneratedCommandsNV-None-02910", @@ -64042,11 +74470,11 @@ "(VK_EXT_opacity_micromap)+(VK_NV_displacement_micromap)": [ { "vuid": "VUID-VkMicromapBuildInfoEXT-type-08704", - "text": " If type is VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV the format member of VkMicromapUsageEXT must be a valid value from VkDisplacementMicromapFormatNV" + "text": " If type is VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV the format member of VkMicromapUsageEXT must be a valid value from VkDisplacementMicromapFormatNV" }, { "vuid": "VUID-VkMicromapBuildInfoEXT-type-08705", - "text": " If type is VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV the format member of VkMicromapTriangleEXT must be a valid value from VkDisplacementMicromapFormatNV" + "text": " If type is VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV the format member of VkMicromapTriangleEXT must be a valid value from VkDisplacementMicromapFormatNV" } ] }, @@ -64068,11 +74496,11 @@ "(VK_EXT_opacity_micromap)+(VK_NV_displacement_micromap)": [ { "vuid": "VUID-VkMicromapUsageEXT-format-08706", - "text": " If the VkMicromapTypeEXT of the micromap is VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV then format must be VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV, VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV or VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV" + "text": " If the VkMicromapTypeEXT of the micromap is VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV then format must be VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV, VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV or VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV" }, { "vuid": "VUID-VkMicromapUsageEXT-subdivisionLevel-08707", - "text": " If the VkMicromapTypeEXT of the micromap is VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV then subdivisionLevel must be less than or equal to VkPhysicalDeviceDisplacementMicromapPropertiesNV::maxDisplacementMicromapSubdivisionLevel" + "text": " If the VkMicromapTypeEXT of the micromap is VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV then subdivisionLevel must be less than or equal to VkPhysicalDeviceDisplacementMicromapPropertiesNV::maxDisplacementMicromapSubdivisionLevel" } ] }, @@ -64094,11 +74522,11 @@ "(VK_EXT_opacity_micromap)+(VK_NV_displacement_micromap)": [ { "vuid": "VUID-VkMicromapTriangleEXT-format-08708", - "text": " If the VkMicromapTypeEXT of the micromap is VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV then format must be VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV, VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV or VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV" + "text": " If the VkMicromapTypeEXT of the micromap is VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV then format must be VK_DISPLACEMENT_MICROMAP_FORMAT_64_TRIANGLES_64_BYTES_NV, VK_DISPLACEMENT_MICROMAP_FORMAT_256_TRIANGLES_128_BYTES_NV or VK_DISPLACEMENT_MICROMAP_FORMAT_1024_TRIANGLES_128_BYTES_NV" }, { "vuid": "VUID-VkMicromapTriangleEXT-subdivisionLevel-08709", - "text": " If the VkMicromapTypeEXT of the micromap is VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV then subdivisionLevel must be less than or equal to VkPhysicalDeviceDisplacementMicromapPropertiesNV::maxDisplacementMicromapSubdivisionLevel" + "text": " If the VkMicromapTypeEXT of the micromap is VK_MICROMAP_TYPE_DISPLACEMENT_MICROMAP_NV then subdivisionLevel must be less than or equal to VkPhysicalDeviceDisplacementMicromapPropertiesNV::maxDisplacementMicromapSubdivisionLevel" } ] }, @@ -64770,30 +75198,6 @@ "vuid": "VUID-vkCmdTraceRaysNV-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" }, - { - "vuid": "VUID-vkCmdTraceRaysNV-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdTraceRaysNV-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdTraceRaysNV-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdTraceRaysNV-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdTraceRaysNV-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdTraceRaysNV-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -65007,24 +75411,102 @@ "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" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdTraceRaysNV-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-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" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-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" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-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" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysNV-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VK_EXT_descriptor_buffer)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysNV-None-02699", "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" } ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdTraceRaysNV-None-08114", @@ -65047,6 +75529,16 @@ "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" } ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-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" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-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" + } + ], "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdTraceRaysNV-None-02705", @@ -65067,13 +75559,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_1)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysNV-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -65083,6 +75581,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysNV-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdTraceRaysNV-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_NV_ray_tracing)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdTraceRaysNV-SampledType-04470", @@ -65162,30 +75670,6 @@ "vuid": "VUID-vkCmdTraceRaysKHR-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" }, - { - "vuid": "VUID-vkCmdTraceRaysKHR-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdTraceRaysKHR-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdTraceRaysKHR-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdTraceRaysKHR-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdTraceRaysKHR-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdTraceRaysKHR-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -65435,24 +75919,102 @@ "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" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdTraceRaysKHR-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-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" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-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" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-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" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysKHR-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_EXT_descriptor_buffer)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysKHR-None-02699", "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" } ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdTraceRaysKHR-None-08114", @@ -65475,6 +76037,16 @@ "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" } ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-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" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-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" + } + ], "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdTraceRaysKHR-None-02705", @@ -65495,13 +76067,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysKHR-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -65511,6 +76089,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysKHR-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdTraceRaysKHR-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdTraceRaysKHR-SampledType-04470", @@ -65670,30 +76258,6 @@ "vuid": "VUID-vkCmdTraceRaysIndirectKHR-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" }, - { - "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -65947,24 +76511,102 @@ "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" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-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" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-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" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-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" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysIndirectKHR-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_EXT_descriptor_buffer)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02699", "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" } ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-08114", @@ -65987,6 +76629,16 @@ "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" } ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-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" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-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" + } + ], "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-02705", @@ -66007,13 +76659,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysIndirectKHR-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -66023,6 +76681,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirectKHR-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdTraceRaysIndirectKHR-SampledType-04470", @@ -66128,30 +76796,6 @@ "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-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" }, - { - "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02697", - "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" - }, - { - "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02700", - "text": " A valid pipeline must be bound to the pipeline bind point used by this command" - }, - { - "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02859", - "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" - }, - { - "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02702", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" - }, - { - "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02703", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" - }, - { - "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02704", - "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" - }, { "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 Instruction/Sampler/Image View Validation" @@ -66281,24 +76925,102 @@ "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" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+!(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+!(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02697", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, { "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02698", "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02700", + "text": " A valid pipeline must be bound to the pipeline bind point used by this command" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02859", + "text": " There must not have been any calls to dynamic state setting commands for any state not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02702", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02703", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02704", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+(VK_VERSION_1_3,VK_KHR_maintenance4)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-08600", + "text": " For each set n that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout array that was used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-08601", + "text": " For each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-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" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-08607", + "text": " If the shaderObject 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" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-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 not specified as dynamic in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-08609", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used to sample from any VkImage with a VkImageView of the type VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, VK_IMAGE_VIEW_TYPE_1D_ARRAY, VK_IMAGE_VIEW_TYPE_2D_ARRAY or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-08610", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions with ImplicitLod, Dref or Proj in their name, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-08611", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler object that uses unnormalized coordinates, that sampler must not be used with any of the SPIR-V OpImageSample* or OpImageSparseSample* instructions that includes a LOD bias or any offset values, in any shader stage" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-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" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-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" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+(VK_VERSION_1_3,VK_KHR_maintenance4)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-maintenance4-06425", "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, 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, as described in Pipeline Layout Compatibility" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+!(VK_EXT_descriptor_buffer)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+(VK_VERSION_1_3,VK_KHR_maintenance4)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-maintenance4-08602", + "text": " If the maintenance4 feature is not enabled, then for each push constant that is statically used by the VkPipeline bound to the pipeline bind point used by this command, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command, 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 or VkDescriptorSetLayout and VkPushConstantRange arrays used to create the current VkPipeline or VkShaderEXT, as described in Pipeline Layout Compatibility" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+!(VK_EXT_descriptor_buffer)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02699", "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" } ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+!(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-08603", + "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, or by any of the VkShaderEXT objects bound to stages corresponding to the pipeline bind point used by this command" + } + ], "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+(VK_EXT_descriptor_buffer)": [ { "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-08114", @@ -66321,6 +77043,16 @@ "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" } ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+(VK_EXT_descriptor_buffer)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-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" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-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" + } + ], "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+!(VK_EXT_pipeline_robustness)": [ { "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-02705", @@ -66341,13 +77073,19 @@ "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_EXT or VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT 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" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+(VK_VERSION_1_1)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+(VK_VERSION_1_1)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-commandBuffer-02707", "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command must not be a protected resource" } ], - "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)": [ + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+(VK_VERSION_1_1)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-commandBuffer-08614", + "text": " If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT object bound to a stage corresponding to the pipeline bind point used by this command must not be a protected resource" + } + ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+!(VK_EXT_shader_object)": [ { "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-06550", "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" @@ -66357,6 +77095,16 @@ "text": " If the VkPipeline object bound to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" } ], + "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+(VK_VERSION_1_1,VK_KHR_sampler_ycbcr_conversion)+(VK_EXT_shader_object)": [ + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-None-08615", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must only be used with OpImageSample* or OpImageSparseSample* instructions" + }, + { + "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-ConstOffset-08616", + "text": " If the VkPipeline object bound to the pipeline bind point used by this command or any VkShaderEXT bound to a stage corresponding to the pipeline bind point used by this command accesses a VkSampler or VkImageView object that enables sampler {YCbCr} conversion, that object must not use the ConstOffset and Offset operands" + } + ], "(VK_NV_ray_tracing,VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_pipeline)+(VK_KHR_ray_tracing_maintenance1)+(VK_EXT_shader_image_atomic_int64)": [ { "vuid": "VUID-vkCmdTraceRaysIndirect2KHR-SampledType-04470", @@ -70278,6 +81026,14 @@ } ] }, + "VkPhysicalDeviceShaderTileImageFeaturesEXT": { + "(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderTileImageFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT" + } + ] + }, "VkPhysicalDeviceAddressBindingReportFeaturesEXT": { "(VK_EXT_device_address_binding_report)": [ { @@ -70310,6 +81066,14 @@ } ] }, + "VkPhysicalDeviceShaderObjectFeaturesEXT": { + "(VK_EXT_shader_object)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderObjectFeaturesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT" + } + ] + }, "VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM": { "(VK_ARM_shader_core_builtins)": [ { @@ -70866,6 +81630,14 @@ } ] }, + "VkPhysicalDeviceShaderObjectPropertiesEXT": { + "(VK_EXT_shader_object)": [ + { + "vuid": "VUID-VkPhysicalDeviceShaderObjectPropertiesEXT-sType-sType", + "text": " sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT" + } + ] + }, "vkGetPhysicalDeviceMultisamplePropertiesEXT": { "(VK_EXT_sample_locations)": [ { @@ -72356,7 +83128,7 @@ }, { "vuid": "VUID-StandaloneSpirv-None-04643", - "text": " Storage Class must be limited to UniformConstant, Input, Uniform, Output, Workgroup, Private, Function, PushConstant, Image, StorageBuffer, RayPayloadKHR, IncomingRayPayloadKHR, HitAttributeKHR, CallableDataKHR, IncomingCallableDataKHR, ShaderRecordBufferKHR, or PhysicalStorageBuffer" + "text": " Storage Class must be limited to UniformConstant, Input, Uniform, Output, Workgroup, Private, Function, PushConstant, Image, StorageBuffer, RayPayloadKHR, IncomingRayPayloadKHR, HitAttributeKHR, CallableDataKHR, IncomingCallableDataKHR, ShaderRecordBufferKHR, PhysicalStorageBuffer, or TileImageEXT" }, { "vuid": "VUID-StandaloneSpirv-None-04644", @@ -72366,6 +83138,10 @@ "vuid": "VUID-StandaloneSpirv-None-04645", "text": " If the Storage Class is Workgroup, then it must only be used in the task, mesh, or compute execution models" }, + { + "vuid": "VUID-StandaloneSpirv-None-08720", + "text": " If the Storage Class is TileImageEXT, then it must only be used in the fragment execution model" + }, { "vuid": "VUID-StandaloneSpirv-OpAtomicStore-04730", "text": " OpAtomicStore must not use Acquire, AcquireRelease, or SequentiallyConsistent memory semantics" @@ -72738,6 +83514,14 @@ "vuid": "VUID-StandaloneSpirv-OpEntryPoint-06674", "text": " Each OpEntryPoint must not statically use more than one OpVariable in the PushConstant storage class" }, + { + "vuid": "VUID-StandaloneSpirv-OpEntryPoint-08721", + "text": " Each OpEntryPoint must not have more than one Input variable assigned the same Component word inside a Location slot, either explicitly or implicitly" + }, + { + "vuid": "VUID-StandaloneSpirv-OpEntryPoint-08722", + "text": " Each OpEntryPoint must not have more than one Output variable assigned the same Component word inside a Location slot, either explicitly or implicitly" + }, { "vuid": "VUID-StandaloneSpirv-Result-04780", "text": " The Result Type operand of any OpImageRead or OpImageSparseRead instruction must be a vector of four components" @@ -72813,6 +83597,14 @@ { "vuid": "VUID-StandaloneSpirv-Input-07290", "text": " Variables with a storage class of Input or Output and a type of OpTypeBool must be decorated with the BuiltIn decoration" + }, + { + "vuid": "VUID-StandaloneSpirv-TileImageEXT-08723", + "text": " The tile image variable declarations must obey the constraints on the TileImageEXT storage class and the Location decoration described in Fragment Tile Image Interface" + }, + { + "vuid": "VUID-StandaloneSpirv-None-08724", + "text": " The TileImageEXT storage class must only be used for declaring tile image variables." } ] }, @@ -72928,19 +83720,19 @@ }, { "vuid": "VUID-RuntimeSpirv-x-06429", - "text": " The x size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[0]" + "text": " The x size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[0]" }, { "vuid": "VUID-RuntimeSpirv-y-06430", - "text": " The y size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[1]" + "text": " The y size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[1]" }, { "vuid": "VUID-RuntimeSpirv-z-06431", - "text": " The z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[2]" + "text": " The z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[2]" }, { "vuid": "VUID-RuntimeSpirv-x-06432", - "text": " The product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupInvocations" + "text": " The product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupInvocations" }, { "vuid": "VUID-RuntimeSpirv-OpEntryPoint-07754", @@ -72965,6 +83757,18 @@ { "vuid": "VUID-RuntimeSpirv-OpImageSample-06436", "text": " If an OpImageSample* or OpImageFetch* operation has an image operand of ConstOffset then the offset value must be less than or equal to maxTexelOffset" + }, + { + "vuid": "VUID-RuntimeSpirv-samples-08725", + "text": " If an OpTypeImage has an MS operand 0, its bound image must have been created with VkImageCreateInfo::samples as VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-RuntimeSpirv-samples-08726", + "text": " If an OpTypeImage has an MS operand 1, its bound image must not have been created with VkImageCreateInfo::samples as VK_SAMPLE_COUNT_1_BIT" + }, + { + "vuid": "VUID-RuntimeSpirv-OpEntryPoint-08727", + "text": " Each OpEntryPoint must not have more than one variable decorated with InputAttachmentIndex per image aspect of the attachment image bound to it, either explicitly or implicitly as described by input attachment interface" } ], "(VK_VERSION_1_2,VK_EXT_descriptor_indexing)": [ @@ -73142,27 +83946,27 @@ "(VK_EXT_transform_feedback)": [ { "vuid": "VUID-RuntimeSpirv-Offset-06308", - "text": " The Offset plus size of the type of each variable, in the output interface of the entry point being compiled, decorated with XfbBuffer must not be greater than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBufferDataSize" + "text": " The Offset plus size of the type of each variable, in the output interface of the entry point being compiled, decorated with XfbBuffer must not be greater than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBufferDataSize" }, { "vuid": "VUID-RuntimeSpirv-XfbBuffer-06309", - "text": " For any given XfbBuffer value, define the buffer data size to be smallest number of bytes such that, for all outputs decorated with the same XfbBuffer value, the size of the output interface variable plus the Offset is less than or equal to the buffer data size. For a given Stream, the sum of all the buffer data sizes for all buffers writing to that stream the must not exceed VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreamDataSize" + "text": " For any given XfbBuffer value, define the buffer data size to be smallest number of bytes such that, for all outputs decorated with the same XfbBuffer value, the size of the output interface variable plus the Offset is less than or equal to the buffer data size. For a given Stream, the sum of all the buffer data sizes for all buffers writing to that stream the must not exceed VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreamDataSize" }, { "vuid": "VUID-RuntimeSpirv-OpEmitStreamVertex-06310", - "text": " The Stream value to OpEmitStreamVertex and OpEndStreamPrimitive must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams" + "text": " The Stream value to OpEmitStreamVertex and OpEndStreamPrimitive must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams" }, { "vuid": "VUID-RuntimeSpirv-transformFeedbackStreamsLinesTriangles-06311", - "text": " If the geometry shader emits to more than one vertex stream and VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackStreamsLinesTriangles is VK_FALSE, then execution mode must be OutputPoints" + "text": " If the geometry shader emits to more than one vertex stream and VkPhysicalDeviceTransformFeedbackPropertiesEXT::transformFeedbackStreamsLinesTriangles is VK_FALSE, then execution mode must be OutputPoints" }, { "vuid": "VUID-RuntimeSpirv-Stream-06312", - "text": " The stream number value to Stream must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams" + "text": " The stream number value to Stream must be less than VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackStreams" }, { "vuid": "VUID-RuntimeSpirv-XfbStride-06313", - "text": " The XFB Stride value to XfbStride must be less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBufferDataStride" + "text": " The XFB Stride value to XfbStride must be less than or equal to VkPhysicalDeviceTransformFeedbackPropertiesEXT::maxTransformFeedbackBufferDataStride" } ], "(VK_VERSION_1_2,VK_EXT_buffer_device_address,VK_KHR_buffer_device_address)": [ @@ -73212,17 +84016,17 @@ "(VK_NV_mesh_shader)": [ { "vuid": "VUID-RuntimeSpirv-MeshNV-07113", - "text": " For mesh shaders using the MeshNV {ExecutionModel} the OutputVertices OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputVertices" + "text": " For mesh shaders using the MeshNV {ExecutionModel} the OutputVertices OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputVertices" }, { "vuid": "VUID-RuntimeSpirv-MeshNV-07114", - "text": " For mesh shaders using the MeshNV {ExecutionModel} the OutputPrimitivesNV OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputPrimitives" + "text": " For mesh shaders using the MeshNV {ExecutionModel} the OutputPrimitivesNV OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputPrimitives" } ], "(VK_EXT_mesh_shader)": [ { "vuid": "VUID-RuntimeSpirv-MeshEXT-07115", - "text": " For mesh shaders using the MeshEXT {ExecutionModel} the OutputVertices OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshOutputVertices" + "text": " For mesh shaders using the MeshEXT {ExecutionModel} the OutputVertices OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshOutputVertices" }, { "vuid": "VUID-RuntimeSpirv-MeshEXT-07332", @@ -73230,7 +84034,7 @@ }, { "vuid": "VUID-RuntimeSpirv-MeshEXT-07116", - "text": " For mesh shaders using the MeshEXT {ExecutionModel} the OutputPrimitivesEXT OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshOutputPrimitives" + "text": " For mesh shaders using the MeshEXT {ExecutionModel} the OutputPrimitivesEXT OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshOutputPrimitives" }, { "vuid": "VUID-RuntimeSpirv-MeshEXT-07333", @@ -73246,51 +84050,51 @@ }, { "vuid": "VUID-RuntimeSpirv-TaskEXT-07291", - "text": " In task shaders using the TaskEXT {ExecutionModel} the x size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupSize[0]" + "text": " In task shaders using the TaskEXT {ExecutionModel} the x size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupSize[0]" }, { "vuid": "VUID-RuntimeSpirv-TaskEXT-07292", - "text": " In task shaders using the TaskEXT {ExecutionModel} the y size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupSize[1]" + "text": " In task shaders using the TaskEXT {ExecutionModel} the y size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupSize[1]" }, { "vuid": "VUID-RuntimeSpirv-TaskEXT-07293", - "text": " In task shaders using the TaskEXT {ExecutionModel} the z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupSize[2]" + "text": " In task shaders using the TaskEXT {ExecutionModel} the z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupSize[2]" }, { "vuid": "VUID-RuntimeSpirv-TaskEXT-07294", - "text": " In task shaders using the TaskEXT {ExecutionModel} the product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupInvocations" + "text": " In task shaders using the TaskEXT {ExecutionModel} the product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupInvocations" }, { "vuid": "VUID-RuntimeSpirv-MeshEXT-07295", - "text": " For mesh shaders using the MeshEXT {ExecutionModel} the x size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupSize[0]" + "text": " For mesh shaders using the MeshEXT {ExecutionModel} the x size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupSize[0]" }, { "vuid": "VUID-RuntimeSpirv-MeshEXT-07296", - "text": " For mesh shaders using the MeshEXT {ExecutionModel} the y size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupSize[1]" + "text": " For mesh shaders using the MeshEXT {ExecutionModel} the y size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupSize[1]" }, { "vuid": "VUID-RuntimeSpirv-MeshEXT-07297", - "text": " For mesh shaders using the MeshEXT {ExecutionModel} the z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupSize[2]" + "text": " For mesh shaders using the MeshEXT {ExecutionModel} the z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupSize[2]" }, { "vuid": "VUID-RuntimeSpirv-MeshEXT-07298", - "text": " For mesh shaders using the MeshEXT {ExecutionModel} the product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupInvocations" + "text": " For mesh shaders using the MeshEXT {ExecutionModel} the product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupInvocations" }, { "vuid": "VUID-RuntimeSpirv-TaskEXT-07299", - "text": " In task shaders using the TaskEXT {ExecutionModel} the value of the “Group Count X” operand of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupCount[0]" + "text": " In task shaders using the TaskEXT {ExecutionModel} the value of the “Group Count X” operand of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupCount[0]" }, { "vuid": "VUID-RuntimeSpirv-TaskEXT-07300", - "text": " In task shaders using the TaskEXT {ExecutionModel} the value of the “Group Count Y” operand of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupCount[1]" + "text": " In task shaders using the TaskEXT {ExecutionModel} the value of the “Group Count Y” operand of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupCount[1]" }, { "vuid": "VUID-RuntimeSpirv-TaskEXT-07301", - "text": " In task shaders using the TaskEXT {ExecutionModel} the value of the “Group Count Z” operand of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupCount[2]" + "text": " In task shaders using the TaskEXT {ExecutionModel} the value of the “Group Count Z” operand of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupCount[2]" }, { "vuid": "VUID-RuntimeSpirv-TaskEXT-07302", - "text": " In task shaders using the TaskEXT {ExecutionModel} the product of the “Group Count” operands of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupTotalCount" + "text": " In task shaders using the TaskEXT {ExecutionModel} the product of the “Group Count” operands of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupTotalCount" } ], "(VK_KHR_portability_subset)": [ @@ -73646,6 +84450,28 @@ "vuid": "VUID-RuntimeSpirv-OpImageBoxFilterQCOM-06990", "text": " If an OpImageBoxFilterQCOM operation is used, then Sampled Texture Image and Box Size parameters must be dynamically uniform" } + ], + "(VK_EXT_shader_tile_image)": [ + { + "vuid": "VUID-RuntimeSpirv-shaderTileImageColorReadAccess-08728", + "text": " If shaderTileImageColorReadAccess is not enabled, OpColorAttachmentReadEXT operation must not be used" + }, + { + "vuid": "VUID-RuntimeSpirv-shaderTileImageDepthReadAccess-08729", + "text": " If shaderTileImageDepthReadAccess is not enabled, OpDepthAttachmentReadEXT operation must not be used" + }, + { + "vuid": "VUID-RuntimeSpirv-shaderTileImageStencilReadAccess-08730", + "text": " If shaderTileImageStencilReadAccess is not enabled, OpStencilAttachmentReadEXT operation must not be used" + }, + { + "vuid": "VUID-RuntimeSpirv-minSampleShading-08731", + "text": " If sample shading is enabled and minSampleShading is 1.0, the sample operand of any OpColorAttachmentReadEXT, OpDepthAttachmentReadEXT, or OpStencilAttachmentReadEXT operation must evaluate to the value of the coverage index for any given fragment invocation" + }, + { + "vuid": "VUID-RuntimeSpirv-minSampleShading-08732", + "text": " If sample shading is enabled and any of the OpColorAttachmentReadEXT, OpDepthAttachmentReadEXT, or OpStencilAttachmentReadEXT operations are used, then minSampleShading must be 1.0" + } ] }, "vkCreateCuFunctionNVX": { diff --git a/registry/vk.xml b/registry/vk.xml index 7252b7e..08b10a0 100644 --- a/registry/vk.xml +++ b/registry/vk.xml @@ -173,7 +173,7 @@ 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 245 +#define VK_HEADER_VERSION 246 // Complete version of this file #define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION) // Version of this file @@ -474,6 +474,7 @@ typedef void* MTLSharedEvent_id; typedef VkFlags VkOpticalFlowExecuteFlagsNV; typedef VkFlags VkPresentScalingFlagsEXT; typedef VkFlags VkPresentGravityFlagsEXT; + typedef VkFlags VkShaderCreateFlagsEXT; Video Core extension typedef VkFlags VkVideoCodecOperationFlagsKHR; @@ -555,6 +556,7 @@ typedef void* MTLSharedEvent_id; VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkOpticalFlowSessionNV) VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkMicromapEXT) + VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderEXT) WSI extensions VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR) @@ -768,6 +770,8 @@ typedef void* MTLSharedEvent_id; + + WSI extensions @@ -5239,12 +5243,13 @@ typedef void* MTLSharedEvent_id; VkShaderStageFlags requiredSubgroupSizeStagesThe shader stages that support specifying a subgroup size - + VkStructureType sType void* pNext uint32_t requiredSubgroupSize + VkStructureType sType void* pNext @@ -7680,10 +7685,10 @@ typedef void* MTLSharedEvent_id; VkStructureType sType void* pNext - + VkFormat displacementBiasAndScaleFormat VkFormat displacementVectorFormat - + VkDeviceOrHostAddressConstKHR displacementBiasAndScaleBuffer VkDeviceSize displacementBiasAndScaleStride VkDeviceOrHostAddressConstKHR displacementVectorBuffer @@ -7693,13 +7698,13 @@ typedef void* MTLSharedEvent_id; VkIndexType indexType VkDeviceOrHostAddressConstKHR indexBuffer VkDeviceSize indexStride - + uint32_t baseTriangle - + uint32_t usageCountsCount const VkMicromapUsageEXT* pUsageCounts const VkMicromapUsageEXT* const* ppUsageCounts - + VkMicromapEXT micromap @@ -8126,6 +8131,47 @@ typedef void* MTLSharedEvent_id; VkMemoryUnmapFlagsKHR flags VkDeviceMemory memory + + VkStructureType sType + void* pNext + VkBool32 shaderObject + + + VkStructureType sType + void* pNext + uint8_t shaderBinaryUUID[VK_UUID_SIZE] + uint32_t shaderBinaryVersion + + + VkStructureType sType + const void* pNext + VkShaderCreateFlagsEXT flags + VkShaderStageFlagBits stage + VkShaderStageFlags nextStage + VkShaderCodeTypeEXT codeType + size_t codeSize + const void* pCode + const char* pName + uint32_t setLayoutCount + const VkDescriptorSetLayout* pSetLayouts + uint32_t pushConstantRangeCount + const VkPushConstantRange* pPushConstantRanges + const VkSpecializationInfo* pSpecializationInfo + + + VkStructureType sType + void* pNext + VkBool32 shaderTileImageColorReadAccess + VkBool32 shaderTileImageDepthReadAccess + VkBool32 shaderTileImageStencilReadAccess + + + VkStructureType sType + void* pNext + VkBool32 shaderTileImageCoherentReadAccelerated + VkBool32 shaderTileImageReadSampleFromPixelRateInvocation + VkBool32 shaderTileImageReadFromHelperInvocation + @@ -10156,6 +10202,19 @@ typedef void* MTLSharedEvent_id; + + + + + + + + + + + + + @@ -14000,6 +14059,34 @@ typedef void* MTLSharedEvent_id; VkDevice device const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo + + VkResult vkCreateShadersEXT + VkDevice device + uint32_t createInfoCount + const VkShaderCreateInfoEXT* pCreateInfos + const VkAllocationCallbacks* pAllocator + VkShaderEXT* pShaders + + + void vkDestroyShaderEXT + VkDevice device + VkShaderEXT shader + const VkAllocationCallbacks* pAllocator + + + VkResult vkGetShaderBinaryDataEXT + VkDevice device + VkShaderEXT shader + size_t* pDataSize + void* pData + + + void vkCmdBindShadersEXT + VkCommandBuffer commandBuffer + uint32_t stageCount + const VkShaderStageFlagBits* pStages + const VkShaderEXT* pShaders + @@ -20756,10 +20843,14 @@ typedef void* MTLSharedEvent_id; - + - - + + + + + + @@ -21617,13 +21708,83 @@ typedef void* MTLSharedEvent_id; - + - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -23529,6 +23690,9 @@ typedef void* MTLSharedEvent_id; + + + @@ -24003,5 +24167,14 @@ typedef void* MTLSharedEvent_id; + + + + + + + + +