RuntimeSpirv

VUID-RuntimeSpirv-OpCooperativeMatrixMulAddKHR-10060

For OpCooperativeMatrixMulAddKHR, if the cooperativeMatrixFlexibleDimensions feature is not enabled, the operands must match a supported VkCooperativeMatrixPropertiesKHR, such that:

• The type of A must have Rows match VkCooperativeMatrixPropertiesKHR::MSize, Columns match VkCooperativeMatrixPropertiesKHR::KSize, Use be MatrixAKHR, and ComponentType match VkCooperativeMatrixPropertiesKHR::AType.
• The type of B must have Rows match VkCooperativeMatrixPropertiesKHR::KSize, Columns match VkCooperativeMatrixPropertiesKHR::NSize, Use be MatrixBKHR, and ComponentType match VkCooperativeMatrixPropertiesKHR::BType.
• The type of C must have Rows match VkCooperativeMatrixPropertiesKHR::MSize, Columns match VkCooperativeMatrixPropertiesKHR::NSize, Use be MatrixAccumulatorKHR, and ComponentType match VkCooperativeMatrixPropertiesKHR::CType.
• The type of Result must have Rows match VkCooperativeMatrixPropertiesKHR::MSize, Columns match VkCooperativeMatrixPropertiesKHR::NSize, Use be MatrixAccumulatorKHR, and ComponentType match VkCooperativeMatrixPropertiesKHR::ResultType.
• If and only if VkCooperativeMatrixPropertiesKHR::AType is a signed integer type, MatrixASignedComponents must be used.
• If and only if VkCooperativeMatrixPropertiesKHR::BType is a signed integer type, MatrixBSignedComponents must be used.
• If and only if VkCooperativeMatrixPropertiesKHR::CType is a signed integer type, MatrixCSignedComponents must be used.
• If and only if VkCooperativeMatrixPropertiesKHR::ResultType is a signed integer type, MatrixResultSignedComponents must be used.
• If and only if VkCooperativeMatrixPropertiesKHR::saturatingAccumulation is VK_TRUE, SaturatingAccumulationKHR must be used.
• If and only if VkCooperativeMatrixPropertiesKHR::saturatingAccumulation is VK_FALSE, SaturatingAccumulationKHR must not be used.
• The scope of all cooperative matrix operands must match VkCooperativeMatrixPropertiesKHR::scope. ::

VUID-RuntimeSpirv-cooperativeMatrixFlexibleDimensions-10166

For OpCooperativeMatrixMulAddKHR, if the cooperativeMatrixFlexibleDimensions feature is enabled, the operands must match either one of the supported VkCooperativeMatrixPropertiesKHR as described above, or one of the supported VkCooperativeMatrixFlexibleDimensionsPropertiesNV, such that:

• The type of A must have Rows be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::MGranularity, Columns be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::KGranularity, Use be MatrixAKHR, and ComponentType match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::AType.
• The type of B must have Rows be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::KGranularity, Columns be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::NGranularity, Use be MatrixBKHR, and ComponentType match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::BType.
• The type of C must have Rows be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::MGranularity, Columns be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::NGranularity, Use be MatrixAccumulatorKHR, and ComponentType match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::CType.
• The type of Result must have Rows be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::MGranularity, Columns be a multiple of VkCooperativeMatrixFlexibleDimensionsPropertiesNV::NGranularity, Use be MatrixAccumulatorKHR, and ComponentType match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::ResultType.
• If and only if VkCooperativeMatrixFlexibleDimensionsPropertiesNV::AType is a signed integer type, MatrixASignedComponents must be used.
• If and only if VkCooperativeMatrixFlexibleDimensionsPropertiesNV::BType is a signed integer type, MatrixBSignedComponents must be used.
• If and only if VkCooperativeMatrixFlexibleDimensionsPropertiesNV::CType is a signed integer type, MatrixCSignedComponents must be used.
• If and only if VkCooperativeMatrixFlexibleDimensionsPropertiesNV::ResultType is a signed integer type, MatrixResultSignedComponents must be used.
• If and only if VkCooperativeMatrixFlexibleDimensionsPropertiesNV::saturatingAccumulation is VK_TRUE, SaturatingAccumulationKHR must be used.
• If and only if VkCooperativeMatrixFlexibleDimensionsPropertiesNV::saturatingAccumulation is VK_FALSE, SaturatingAccumulationKHR must not be used.
• The scope of all cooperative matrix operands must match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::scope.
• If the scope is VK_SCOPE_WORKGROUP_KHR, the number of invocations in the local workgroup must match VkCooperativeMatrixFlexibleDimensionsPropertiesNV::workgroupInvocations ::

VUID-RuntimeSpirv-OpCooperativeVectorMatrixMulNV-10090

For OpCooperativeVectorMatrixMulNV and OpCooperativeVectorMatrixMulAddNV, if MatrixInterpretation is either VK_COMPONENT_TYPE_FLOAT_E4M3_NV or VK_COMPONENT_TYPE_FLOAT_E5M2_NV then MemoryLayout must be either VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV or VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV

VUID-RuntimeSpirv-cooperativeVectorSupportedStages-10091

OpTypeCooperativeVectorNV and OpCooperativeVector* instructions must not be used in shader stages not included in VkPhysicalDeviceCooperativeVectorPropertiesNV::cooperativeVectorSupportedStages

VUID-RuntimeSpirv-OpCooperativeVectorReduceSumAccumulateNV-10092

For OpCooperativeVectorReduceSumAccumulateNV:

• The component type of V must be either 16- or 32-bit floating-point
• If the component type of V is 16-bit floating-point, cooperativeVectorTrainingFloat16Accumulation must be supported
• If the component type of V is 32-bit floating-point, cooperativeVectorTrainingFloat32Accumulation must be supported
• The pointer’s storage class must be StorageBuffer or PhysicalStorageBuffer ::

VUID-RuntimeSpirv-OpTypeCooperativeVector-10095

OpTypeCooperativeVector instructions must have Component

Type that is any supported type reported by vkGetPhysicalDeviceCooperativeVectorPropertiesNV

VUID-RuntimeSpirv-MeshNV-07113

For mesh shaders using the MeshNV Execution Model the OutputVertices OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputVertices

VUID-RuntimeSpirv-MeshNV-07114

For mesh shaders using the MeshNV Execution Model the OutputPrimitivesNV OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesNV::maxMeshOutputPrimitives

VUID-RuntimeSpirv-MeshEXT-07115

For mesh shaders using the MeshEXT Execution Model the OutputVertices OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshOutputVertices

VUID-RuntimeSpirv-MeshEXT-07332

For mesh shaders using the MeshEXT Execution Model the Vertex Count operand of OpSetMeshOutputsEXT must be less than or equal to OutputVertices OpExecutionMode

VUID-RuntimeSpirv-MeshEXT-07116

For mesh shaders using the MeshEXT Execution Model the OutputPrimitivesEXT OpExecutionMode must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshOutputPrimitives

VUID-RuntimeSpirv-MeshEXT-07333

For mesh shaders using the MeshEXT Execution Model the Primitive Count operand of OpSetMeshOutputsEXT must be less than or equal to OutputPrimitivesEXT OpExecutionMode

VUID-RuntimeSpirv-TaskEXT-07117

In task shaders using the TaskEXT Execution Model

OpEmitMeshTasksEXT must be called exactly once under dynamically uniform conditions

VUID-RuntimeSpirv-MeshEXT-07118

In mesh shaders using the MeshEXT Execution Model

OpSetMeshOutputsEXT must be called at most once under dynamically uniform conditions

VUID-RuntimeSpirv-TaskEXT-07291

In task shaders using the TaskEXT Execution Model the x size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupSize[0]

VUID-RuntimeSpirv-TaskEXT-07292

In task shaders using the TaskEXT Execution Model the y size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupSize[1]

VUID-RuntimeSpirv-TaskEXT-07293

In task shaders using the TaskEXT Execution Model the z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupSize[2]

VUID-RuntimeSpirv-TaskEXT-07294

In task shaders using the TaskEXT Execution Model the product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxTaskWorkGroupInvocations

VUID-RuntimeSpirv-MeshEXT-07295

For mesh shaders using the MeshEXT Execution Model the x size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupSize[0]

VUID-RuntimeSpirv-MeshEXT-07296

For mesh shaders using the MeshEXT Execution Model the y size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupSize[1]

VUID-RuntimeSpirv-MeshEXT-07297

For mesh shaders using the MeshEXT Execution Model the z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupSize[2]

VUID-RuntimeSpirv-MeshEXT-07298

For mesh shaders using the MeshEXT Execution Model the product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupInvocations

VUID-RuntimeSpirv-TaskEXT-07299

In task shaders using the TaskEXT Execution Model the value of the Group Count X operand of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupCount[0]

VUID-RuntimeSpirv-TaskEXT-07300

In task shaders using the TaskEXT Execution Model the value of the Group Count Y operand of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupCount[1]

VUID-RuntimeSpirv-TaskEXT-07301

In task shaders using the TaskEXT Execution Model the value of the Group Count Z operand of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupCount[2]

VUID-RuntimeSpirv-TaskEXT-07302

In task shaders using the TaskEXT Execution Model the product of the Group Count operands of OpEmitMeshTasksEXT must be less than or equal to VkPhysicalDeviceMeshShaderPropertiesEXT::maxMeshWorkGroupTotalCount

VUID-RuntimeSpirv-maxMeshSharedMemorySize-08754

The sum of size in bytes for variables and padding in the Workgroup Storage Class in the MeshEXT

Execution Model must be less than or equal to maxMeshSharedMemorySize

VUID-RuntimeSpirv-maxMeshPayloadAndSharedMemorySize-08755

The sum of size in bytes for variables and padding in the TaskPayloadWorkgroupEXT or Workgroup

Storage Class in the MeshEXT Execution Model must be less than or equal to maxMeshPayloadAndSharedMemorySize

VUID-RuntimeSpirv-maxMeshOutputMemorySize-08756

The sum of size in bytes for variables in the Output Storage Class in the MeshEXT Execution Model must be less than or equal to maxMeshOutputMemorySize according to the formula in Mesh Shader Output

VUID-RuntimeSpirv-maxMeshPayloadAndOutputMemorySize-08757

The sum of size in bytes for variables and in the TaskPayloadWorkgroupEXT or Output Storage Class in the MeshEXT Execution Model must be less than or equal to maxMeshPayloadAndOutputMemorySize according to the formula in Mesh Shader Output

VUID-RuntimeSpirv-maxTaskPayloadSize-08758

The sum of size in bytes for variables and in the TaskPayloadWorkgroupEXT Storage Class in the TaskEXT

Execution Model must be less than or equal to maxTaskPayloadSize

VUID-RuntimeSpirv-maxTaskSharedMemorySize-08759

The sum of size in bytes for variables and padding in the Workgroup Storage Class in the TaskEXT

Execution Model must be less than or equal to maxTaskSharedMemorySize

VUID-RuntimeSpirv-maxTaskPayloadAndSharedMemorySize-08760

The sum of size in bytes for variables and padding in the TaskPayloadWorkgroupEXT or Workgroup

Storage Class in the TaskEXT Execution Model must be less than or equal to maxTaskPayloadAndSharedMemorySize

VUID-RuntimeSpirv-OpCooperativeMatrixLoadKHR-08986

For OpCooperativeMatrixLoadKHR and OpCooperativeMatrixStoreKHR instructions, the Pointer and Stride operands must be aligned to at least the lesser of 16 bytes or the natural alignment of a row or column (depending on ColumnMajor) of the matrix (where the natural alignment is the number of columns/rows multiplied by the component size)

VUID-RuntimeSpirv-OpCooperativeVectorMatrixMulNV-10096

For OpCooperativeVectorMatrixMulNV and OpCooperativeVectorMatrixMulAddNV instructions using non-optimal layouts, the Stride operand must be aligned to 16 bytes

VUID-RuntimeSpirv-OpCooperativeVectorMatrixMulNV-10097

For OpCooperativeVectorMatrixMulNV and OpCooperativeVectorMatrixMulAddNV instructions, the Matrix and MatrixOffset must be aligned to 64 bytes

VUID-RuntimeSpirv-OpCooperativeVectorMatrixMulAddNV-10098

For OpCooperativeVectorMatrixMulAddNV instructions, the Bias and BiasOffset must be aligned to 16 bytes

VUID-RuntimeSpirv-OpCooperativeVectorLoadNV-10099

For OpCooperativeVectorLoadNV and OpCooperativeVectorStoreNV instructions, the Pointer and Offset must be aligned to 16 bytes

VUID-RuntimeSpirv-OpCooperativeVectorReduceSumAccumulateNV-10100

For OpCooperativeVectorReduceSumAccumulateNV instructions, the Pointer and Offset must be aligned to 16 bytes

VUID-RuntimeSpirv-OpCooperativeVectorOuterProductAccumulateNV-10101

For OpCooperativeVectorOuterProductAccumulateNV instructions, the Pointer and Offset must be aligned to 64 bytes

VUID-RuntimeSpirv-shaderSampleRateInterpolationFunctions-06325

If the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::shaderSampleRateInterpolationFunctions is VK_FALSE, then GLSL.std.450 fragment interpolation functions are not supported by the implementation and OpCapability must not be InterpolationFunction

VUID-RuntimeSpirv-tessellationShader-06326

If the tessellationShader feature is enabled, and the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::tessellationIsolines is VK_FALSE, then OpExecutionMode must not be IsoLines

VUID-RuntimeSpirv-tessellationShader-06327

If the tessellationShader feature is enabled, and the VK_KHR_portability_subset extension is enabled, and VkPhysicalDevicePortabilitySubsetFeaturesKHR::tessellationPointMode is VK_FALSE, then OpExecutionMode must not be PointMode

VUID-RuntimeSpirv-storageBuffer8BitAccess-06328

If storageBuffer8BitAccess is VK_FALSE, then objects containing an 8-bit integer element must not have Storage Class of StorageBuffer, ShaderRecordBufferKHR, or PhysicalStorageBuffer

VUID-RuntimeSpirv-uniformAndStorageBuffer8BitAccess-06329

If uniformAndStorageBuffer8BitAccess is VK_FALSE, then objects in the Uniform Storage Class with the Block decoration must not have an 8-bit integer member

VUID-RuntimeSpirv-storagePushConstant8-06330

If storagePushConstant8 is VK_FALSE, then objects containing an 8-bit integer element must not have Storage Class of PushConstant

VUID-RuntimeSpirv-storageBuffer16BitAccess-06331

If storageBuffer16BitAccess is VK_FALSE, then objects containing 16-bit integer or 16-bit floating-point elements must not have Storage Class of StorageBuffer, ShaderRecordBufferKHR, or PhysicalStorageBuffer

VUID-RuntimeSpirv-uniformAndStorageBuffer16BitAccess-06332

If uniformAndStorageBuffer16BitAccess is VK_FALSE, then objects in the Uniform Storage Class with the Block decoration must not have 16-bit integer or 16-bit floating-point members

VUID-RuntimeSpirv-storagePushConstant16-06333

If storagePushConstant16 is VK_FALSE, then objects containing 16-bit integer or 16-bit floating-point elements must not have Storage Class of PushConstant

VUID-RuntimeSpirv-storageInputOutput16-06334

If storageInputOutput16 is VK_FALSE, then objects containing 16-bit integer or 16-bit floating-point elements must not have Storage Class of Input or Output

VUID-RuntimeSpirv-None-06337

shaderBufferFloat16Atomics, or shaderBufferFloat16AtomicAdd, or shaderBufferFloat16AtomicMinMax, or shaderSharedFloat16Atomics, or shaderSharedFloat16AtomicAdd, or shaderSharedFloat16AtomicMinMax must be enabled for 16-bit floating-point atomic operations

VUID-RuntimeSpirv-None-06338

shaderBufferFloat32Atomics, or shaderBufferFloat32AtomicAdd, or shaderSharedFloat32Atomics, or shaderSharedFloat32AtomicAdd, or shaderImageFloat32Atomics, or shaderImageFloat32AtomicAdd or shaderBufferFloat32AtomicMinMax, or shaderSharedFloat32AtomicMinMax, or shaderImageFloat32AtomicMinMax must be enabled for 32-bit floating-point atomic operations

VUID-RuntimeSpirv-None-06339

shaderBufferFloat64Atomics, or shaderBufferFloat64AtomicAdd, or shaderSharedFloat64Atomics, or shaderSharedFloat64AtomicAdd, or shaderBufferFloat64AtomicMinMax, or shaderSharedFloat64AtomicMinMax, must be enabled for 64-bit floating-point atomic operations

VUID-RuntimeSpirv-shaderFloat16VectorAtomics-09581

shaderFloat16VectorAtomics, must be enabled for 16-bit floating-point, 2- and 4-component vector atomic operations to be supported

VUID-RuntimeSpirv-NonWritable-06340

If the fragmentStoresAndAtomics feature is not enabled, then all storage image, storage texel buffer, and storage buffer variables in the fragment stage must be decorated with the NonWritable decoration

VUID-RuntimeSpirv-NonWritable-06341

If the vertexPipelineStoresAndAtomics feature is not enabled, then all storage image, storage texel buffer, and storage buffer variables in the vertex, tessellation, and geometry stages must be decorated with the NonWritable decoration

VUID-RuntimeSpirv-None-06342

If subgroupQuadOperationsInAllStages is VK_FALSE, then quad subgroup operations must not be used except for in fragment and compute stages

VUID-RuntimeSpirv-Offset-06344

The first element of the Offset operand of InterpolateAtOffsetmust be greater than or equal to:\

frag_width × minInterpolationOffset\

where frag_width is the width of the current fragment in pixels

VUID-RuntimeSpirv-Offset-06345

The first element of the Offset operand of InterpolateAtOffsetmust be less than or equal to\

frag_width × (maxInterpolationOffset + ULP ) - ULP\

where frag_width is the width of the current fragment in pixels and ULP = 1 / 2^subPixelInterpolationOffsetBits^

VUID-RuntimeSpirv-Offset-06346

The second element of the Offset operand of InterpolateAtOffset must be greater than or equal to\

frag_height × minInterpolationOffset\

where frag_height is the height of the current fragment in pixels

VUID-RuntimeSpirv-Offset-06347

The second element of the Offset operand of InterpolateAtOffset must be less than or equal to\

frag_height × (maxInterpolationOffset + ULP ) - ULP\

where frag_height is the height of the current fragment in pixels and ULP = 1 / 2^subPixelInterpolationOffsetBits^

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06348

For OpRayQueryInitializeKHR instructions, all components of the RayOrigin and RayDirection operands must be finite floating-point values

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06349

For OpRayQueryInitializeKHR instructions, the RayTmin and RayTmax operands must be non-negative floating-point values

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06350

For OpRayQueryInitializeKHR instructions, the RayTmin operand must be less than or equal to the RayTmax operand

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06351

For OpRayQueryInitializeKHR instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06352

For OpRayQueryInitializeKHR instructions, Acceleration

Structure must be an acceleration structure built as a top-level acceleration structure

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06889

For OpRayQueryInitializeKHR instructions, the Rayflags operand must not contain both SkipTrianglesKHR and SkipAABBsKHR

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06890

For OpRayQueryInitializeKHR instructions, the Rayflags operand must not contain more than one of SkipTrianglesKHR, CullBackFacingTrianglesKHR, and CullFrontFacingTrianglesKHR

VUID-RuntimeSpirv-OpRayQueryInitializeKHR-06891

For OpRayQueryInitializeKHR instructions, the Rayflags operand must not contain more than one of OpaqueKHR, NoOpaqueKHR, CullOpaqueKHR, and CullNoOpaqueKHR

VUID-RuntimeSpirv-OpRayQueryGenerateIntersectionKHR-06353

For OpRayQueryGenerateIntersectionKHR instructions, Hit Tmust satisfy the condition RayTmin ≤ Hit T ≤ RayTmax, where RayTmin is equal to the value returned by OpRayQueryGetRayTMinKHR with the same ray query object, and RayTmax is equal to the value of OpRayQueryGetIntersectionTKHR for the current committed intersection with the same ray query object

VUID-RuntimeSpirv-OpRayQueryGenerateIntersectionKHR-06354

For OpRayQueryGenerateIntersectionKHR instructions, Acceleration Structure must not be built with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags

VUID-RuntimeSpirv-flags-08761

For OpRayQueryGetIntersectionTriangleVertexPositionsKHR instructions, Acceleration Structure must have been built with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR in flags

VUID-RuntimeSpirv-OpTraceRayKHR-06355

For OpTraceRayKHR instructions, all components of the RayOrigin and RayDirection operands must be finite floating-point values

VUID-RuntimeSpirv-OpTraceRayKHR-06356

For OpTraceRayKHR instructions, the RayTmin and RayTmax operands must be non-negative floating-point values

VUID-RuntimeSpirv-OpTraceRayKHR-06552

For OpTraceRayKHR instructions, the Rayflags operand must not contain both SkipTrianglesKHR and SkipAABBsKHR

VUID-RuntimeSpirv-OpTraceRayKHR-06892

For OpTraceRayKHR instructions, the Rayflags operand must not contain more than one of SkipTrianglesKHR, CullBackFacingTrianglesKHR, and CullFrontFacingTrianglesKHR

VUID-RuntimeSpirv-OpTraceRayKHR-06893

For OpTraceRayKHR instructions, the Rayflags operand must not contain more than one of OpaqueKHR, NoOpaqueKHR, CullOpaqueKHR, and CullNoOpaqueKHR

VUID-RuntimeSpirv-OpTraceRayKHR-06553

For OpTraceRayKHR instructions, if the Rayflags operand contains SkipTrianglesKHR, the pipeline must not have been created with VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR set

VUID-RuntimeSpirv-OpTraceRayKHR-06554

For OpTraceRayKHR instructions, if the Rayflags operand contains SkipAABBsKHR, the pipeline must not have been created with VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR set

VUID-RuntimeSpirv-OpTraceRayKHR-06357

For OpTraceRayKHR instructions, the RayTmin operand must be less than or equal to the RayTmax operand

VUID-RuntimeSpirv-OpTraceRayKHR-06358

For OpTraceRayKHR instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs

VUID-RuntimeSpirv-OpTraceRayKHR-06359

For OpTraceRayKHR instructions, Acceleration Structuremust be an acceleration structure built as a top-level acceleration structure

VUID-RuntimeSpirv-OpReportIntersectionKHR-06998

The value of the Hit Kind operand of OpReportIntersectionKHRmust be in the range [0,127]

VUID-RuntimeSpirv-OpTraceRayKHR-06360

For OpTraceRayKHR instructions, if Acceleration Structure was built with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags, the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set

VUID-RuntimeSpirv-OpTraceRayMotionNV-06361

For OpTraceRayMotionNV instructions, all components of the RayOrigin and RayDirection operands must be finite floating-point values

VUID-RuntimeSpirv-OpTraceRayMotionNV-06362

For OpTraceRayMotionNV instructions, the RayTmin and RayTmax operands must be non-negative floating-point values

VUID-RuntimeSpirv-OpTraceRayMotionNV-06363

For OpTraceRayMotionNV instructions, the RayTmin operand must be less than or equal to the RayTmax operand

VUID-RuntimeSpirv-OpTraceRayMotionNV-06364

For OpTraceRayMotionNV instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs

VUID-RuntimeSpirv-OpTraceRayMotionNV-06365

For OpTraceRayMotionNV instructions, Acceleration

Structure must be an acceleration structure built as a top-level acceleration structure with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags

VUID-RuntimeSpirv-OpTraceRayMotionNV-06366

For OpTraceRayMotionNV instructions the time operand must be between 0.0 and 1.0

VUID-RuntimeSpirv-OpTraceRayMotionNV-06367

For OpTraceRayMotionNV instructions the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set

VUID-RuntimeSpirv-OpHitObjectTraceRayMotionNV-07704

For OpHitObjectTraceRayMotionNV instructions, if Acceleration

Structure was built with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags, the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07705

For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, all components of the RayOrigin and RayDirection operands must be finite floating-point values

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07706

For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, the RayTmin and RayTmax operands must be non-negative floating-point values

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07707

For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, the RayTmin operand must be less than or equal to the RayTmax operand

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07708

For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, RayOrigin, RayDirection, RayTmin, and RayTmax operands must not contain NaNs

VUID-RuntimeSpirv-OpHitObjectTraceRayMotionNV-07709

For OpHitObjectTraceRayMotionNV instructions, Acceleration

Structure must be an acceleration structure built as a top-level acceleration structure with VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV in flags

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07710

For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions the time operand must be between 0.0 and 1.0

VUID-RuntimeSpirv-OpHitObjectTraceRayMotionNV-07711

For OpHitObjectTraceRayMotionNV instructions the pipeline must have been created with VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV set

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07712

For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, the Rayflags operand must not contain both SkipTrianglesKHR and SkipAABBsKHR

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07713

For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, the Rayflags operand must not contain more than one of SkipTrianglesKHR, CullBackFacingTrianglesKHR, and CullFrontFacingTrianglesKHR

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07714

For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, the Rayflags operand must not contain more than one of OpaqueKHR, NoOpaqueKHR, CullOpaqueKHR, and CullNoOpaqueKHR

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07715

For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, if the Rayflags operand contains SkipTrianglesKHR, the pipeline must not have been created with VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR set

VUID-RuntimeSpirv-OpHitObjectTraceRayNV-07716

For OpHitObjectTraceRayNV and OpHitObjectTraceRayMotionNV instructions, if the Rayflags operand contains SkipAABBsKHR, the pipeline must not have been created with VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR set

VUID-RuntimeSpirv-x-06429

In compute shaders using the GLCompute Execution Model the x size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[0]

VUID-RuntimeSpirv-y-06430

In compute shaders using the GLCompute Execution Model the y size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[1]

VUID-RuntimeSpirv-z-06431

In compute shaders using the GLCompute Execution Model the z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupSize[2]

VUID-RuntimeSpirv-x-06432

In compute shaders using the GLCompute Execution Model the product of x size, y size, and z size in LocalSize or LocalSizeId must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupInvocations

VUID-RuntimeSpirv-LocalSizeId-06434

If Execution Mode LocalSizeId is used, maintenance4 must be enabled

VUID-RuntimeSpirv-maintenance4-06817

If the maintenance4 feature is not enabled, any OpTypeVector output interface variables must not have a higher Component Count than a matching OpTypeVector input interface variable

VUID-RuntimeSpirv-OpEntryPoint-08743

Any user-defined variables shared between the OpEntryPoint of two shader stages, and declared with Input as its Storage Class for the subsequent shader stage, must have all Location slots and Component words declared in the preceding shader stage’s OpEntryPoint with Output as the Storage Class

VUID-RuntimeSpirv-OpEntryPoint-07754

Any user-defined variables between the OpEntryPoint of two shader stages must have the same type and width for each Component

VUID-RuntimeSpirv-OpVariable-08746

Any OpVariable, Block-decorated OpTypeStruct, or Block-decorated OpTypeStruct members shared between the OpEntryPoint of two shader stages must have matching decorations as defined in interface matching

VUID-RuntimeSpirv-Workgroup-06530

The sum of size in bytes for variables and padding in the Workgroup Storage Class in the GLCompute

Execution Model must be less than or equal to maxComputeSharedMemorySize

VUID-RuntimeSpirv-shaderZeroInitializeWorkgroupMemory-06372

If the shaderZeroInitializeWorkgroupMemory feature is not enabled, any OpVariable with Workgroup as its Storage Class must not have an Initializer operand

VUID-RuntimeSpirv-Offset-10213

If the maintenance8 feature is not enabled, image operand Offset must only be used with OpImage*Gather instructions

VUID-RuntimeSpirv-OpImage-06376

If an OpImage*Gather operation has an image operand of Offset, ConstOffset, or ConstOffsets the offset value must be greater than or equal to minTexelGatherOffset

VUID-RuntimeSpirv-OpImage-06377

If an OpImage*Gather operation has an image operand of Offset, ConstOffset, or ConstOffsets the offset value must be less than or equal to maxTexelGatherOffset

VUID-RuntimeSpirv-OpImageSample-06435

If an `OpImageSample*` or `OpImageFetch*` operation has an image
operand of

Offset or ConstOffset then the offset value must be greater than or equal to minTexelOffset

VUID-RuntimeSpirv-OpImageSample-06436

If an `OpImageSample*` or `OpImageFetch*` operation has an image
operand of

Offset or ConstOffset then the offset value must be less than or equal to maxTexelOffset

VUID-RuntimeSpirv-samples-08725

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-RuntimeSpirv-samples-08726

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-RuntimeSpirv-SampleRateShading-06378

If the subpass description contains VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM, then the SPIR-V fragment shader Capability SampleRateShading must not be enabled

VUID-RuntimeSpirv-SubgroupUniformControlFlowKHR-06379

The Execution Mode SubgroupUniformControlFlowKHR must not be applied to an entry point unless the shaderSubgroupUniformControlFlow feature is enabled, the corresponding shader stage bit is set in subgroupSupportedStages, and the entry point does not execute any invocation repack instructions

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06767

If the shaderEarlyAndLateFragmentTests feature is not enabled, the EarlyAndLateFragmentTestsEXT Execution Mode must not be used

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06768

If the shaderEarlyAndLateFragmentTests feature is not enabled, the StencilRefUnchangedFrontEXT Execution Mode must not be used

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06769

If the shaderEarlyAndLateFragmentTests feature is not enabled, the StencilRefUnchangedBackEXT Execution Mode must not be used

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06770

If the shaderEarlyAndLateFragmentTests feature is not enabled, the StencilRefGreaterFrontEXT Execution Mode must not be used

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06771

If the shaderEarlyAndLateFragmentTests feature is not enabled, the StencilRefGreaterBackEXT Execution Mode must not be used

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06772

If the shaderEarlyAndLateFragmentTests feature is not enabled, the StencilRefLessFrontEXT Execution Mode must not be used

VUID-RuntimeSpirv-shaderEarlyAndLateFragmentTests-06773

If the shaderEarlyAndLateFragmentTests feature is not enabled, the StencilRefLessBackEXT Execution Mode must not be used

VUID-RuntimeSpirv-OpImageWeightedSampleQCOM-06979

If an OpImageWeightedSampleQCOM operation is used, then the Texture Sampled Image and Weight Image parameters must both be dynamically uniform for the quad

VUID-RuntimeSpirv-OpImageWeightedSampleQCOM-06980

If an OpImageWeightedSampleQCOM operation is used, then the Weight Image parameter must be of Storage Class

UniformConstant and type OpTypeImage with Depth=0, Dim=2D, Arrayed=1, MS=0, and Sampled=1

VUID-RuntimeSpirv-OpImageWeightedSampleQCOM-06981

If an OpImageWeightedSampleQCOM operation is used, then the Weight Image parameter must be decorated with WeightTextureQCOM

VUID-RuntimeSpirv-OpImageBlockMatchSADQCOM-06982

If an OpImageBlockMatchSADQCOM or OpImageBlockMatchSSDQCOM operation is used, then the target sampled image, reference sampled image, and Block Size parameters must both be dynamically uniform for the quad

VUID-RuntimeSpirv-OpImageBlockMatchSSDQCOM-06983

If an OpImageBlockMatchSSDQCOM or OpImageBlockMatchSADQCOM operation is used, then target sampled image and reference sampled image parameters must be of storage class UniformConstant and type OpTypeImage with Depth=0, Dim=2D, Arrayed=0, MS=0, and Sampled=1

VUID-RuntimeSpirv-OpImageBlockMatchSSDQCOM-06984

If an OpImageBlockMatchSSDQCOM or OpImageBlockMatchSADQCOM operation is used, then the target sampled image and reference sampled image parameters must be decorated with BlockMatchTextureQCOM

VUID-RuntimeSpirv-OpImageBlockMatchSSDQCOM-06985

If an OpImageBlockMatchSSDQCOM or OpImageBlockMatchSADQCOM operation is used, then target sampled image and reference sampled image parameters must have been created using an identical sampler object

VUID-RuntimeSpirv-OpImageBlockMatchSSDQCOM-06986

If an OpImageBlockMatchSSDQCOM or OpImageBlockMatchSADQCOM operation is used, then target sampled image and reference sampled image parameters must have been created with a sampler object with unnormalizedCoordinates equal to VK_TRUE

VUID-RuntimeSpirv-OpImageBlockMatchSSDQCOM-06987

If an OpImageBlockMatchSSDQCOM or OpImageBlockMatchSADQCOM operation is used, then target sampled image and reference sampled image parameters must have been created with a sampler object with unnormalizedCoordinates equal to VK_TRUE

VUID-RuntimeSpirv-OpImageBlockMatchSSDQCOM-06988

If an OpImageBlockMatchSSDQCOM or OpImageBlockMatchSADQCOM operation is used, then Block Size less than or equal to maxBlockMatchRegion

VUID-RuntimeSpirv-OpImageBoxFilterQCOM-06989

If an OpImageBoxFilterQCOM operation is used, then Box

Size.y must be equal to or greater than 1.0 and less than or equal to maxBoxFilterBlockSize.height

VUID-RuntimeSpirv-OpImageBoxFilterQCOM-06990

If an OpImageBoxFilterQCOM operation is used, then Sampled

Texture Image and Box Size parameters must be dynamically uniform

VUID-RuntimeSpirv-OpEntryPoint-08727

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

VUID-RuntimeSpirv-minSampleShading-08731

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-RuntimeSpirv-minSampleShading-08732

If sample shading is enabled and any of the OpColorAttachmentReadEXT, OpDepthAttachmentReadEXT, or OpStencilAttachmentReadEXT operations are used, then minSampleShading must be 1.0

VUID-RuntimeSpirv-MeshEXT-09218

In mesh shaders using the MeshEXT or MeshNV Execution Model and the OutputPoints Execution Mode, if the maintenance5 feature is not enabled, and if the number of output points is greater than 0, a PointSize decorated variable must be written to for each output point

VUID-RuntimeSpirv-maintenance5-09190

If the maintenance5 feature is enabled and a PointSize decorated variable is written to, all execution paths must write to a PointSize decorated variable

VUID-RuntimeSpirv-ShaderEnqueueAMDX-09191

The ShaderEnqueueAMDX capability must only be used in shaders with the GLCompute or MeshEXT execution model

VUID-RuntimeSpirv-NodePayloadAMDX-09192

Variables in the NodePayloadAMDX storage class must only be declared in the GLCompute or MeshEXT execution model

VUID-RuntimeSpirv-maxExecutionGraphShaderPayloadSize-09193

Variables declared in the NodePayloadAMDX storage class must not be larger than the maxExecutionGraphShaderPayloadSize limit

VUID-RuntimeSpirv-maxExecutionGraphShaderPayloadSize-09194

Variables declared in the NodeOutputPayloadAMDX storage class must not be larger than the maxExecutionGraphShaderPayloadSize limit

VUID-RuntimeSpirv-maxExecutionGraphShaderPayloadSize-09195

For a given entry point, the sum of the size of any variable in the NodePayloadAMDX storage class, and the combined size of all statically initialized variables in the NodeOutputPayloadAMDX storage class must not be greater than maxExecutionGraphShaderPayloadSize

VUID-RuntimeSpirv-maxExecutionGraphShaderPayloadCount-09196

Shaders must not statically initialize more than maxExecutionGraphShaderPayloadCount variables in the NodeOutputPayloadAMDX storage class

VUID-RuntimeSpirv-maxExecutionGraphShaderOutputNodes-09197

Shaders must not include more than maxExecutionGraphShaderOutputNodes instances of OpInitializeNodePayloadsAMDX

VUID-RuntimeSpirv-OpImageBlockMatchWindow-09219

If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then the target sampled image, reference sampled

image, and Block Size parameters must both be dynamically uniform for the quad

VUID-RuntimeSpirv-OpImageBlockMatchWindow-09220

If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then target

sampled image and reference sampled image parameters must be of storage class UniformConstant and type OpTypeImage with Depth=0, Dim=2D, Arrayed=0, MS=0, and Sampled=1

VUID-RuntimeSpirv-OpImageBlockMatchWindow-09221

If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then the target sampled image and reference sampled

image parameters must be decorated with BlockMatchTextureQCOM

VUID-RuntimeSpirv-OpImageBlockMatchWindow-09222

If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then target

sampled image and reference sampled image parameters must have been created using an identical sampler object

VUID-RuntimeSpirv-OpImageBlockMatchWindow-09223

If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then target

sampled image and reference sampled image parameters must have been created with a sampler object with unnormalizedCoordinates equal to VK_TRUE

VUID-RuntimeSpirv-OpImageBlockMatchWindow-09224

If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then target

sampled image and reference sampled image parameters must have been created with sampler object with unnormalizedCoordinates equal to VK_TRUE

VUID-RuntimeSpirv-maxBlockMatchRegion-09225

If a OpImageBlockMatchWindow*QCOM or OpImageBlockMatchGather*QCOM operation is used, then Block

Size less than or equal to maxBlockMatchRegion

VUID-RuntimeSpirv-pNext-09226

If a OpImageBlockMatchWindow*QCOM operation is used, then target sampled image must have been created using asampler object that included VkSamplerBlockMatchWindowCreateInfoQCOM in the pNext chain

VUID-RuntimeSpirv-MaximallyReconvergesKHR-09565

The execution mode MaximallyReconvergesKHR must not be applied to an entry point unless the entry point does not execute any invocation repack instructions

VUID-RuntimeSpirv-shaderSubgroupRotateClustered-09566

If shaderSubgroupRotateClustered is VK_FALSE, then the ClusterSize operand to OpGroupNonUniformRotateKHR must not be used

VUID-RuntimeSpirv-protectedNoFault-09645

If protectedNoFault is not supported, the Storage Class of the PhysicalStorageBuffer must not be used if the buffer being accessed is protected

VUID-RuntimeSpirv-meshAndTaskShaderDerivatives-10153

If meshAndTaskShaderDerivatives is VK_FALSE, the DerivativeGroupLinearKHR and DerivativeGroupQuadsKHR execution modes must not be used in the MeshEXT, MeshNV, TaskEXT, or TaskNV Execution Model

VUID-RuntimeSpirv-TileShadingQCOM-10698

TileShadingQCOM capability must not be declared in the compute stage unless the tileShading feature is enabled

VUID-RuntimeSpirv-TileShadingQCOM-10699

The TileShadingQCOM capability must not be declared in the fragment stage unless the tileShadingFragmentStage feature is enabled

VUID-RuntimeSpirv-TileShadingQCOM-10700

A shader that enables SPIR-V capability TileShadingQCOM must not be invoked outside a tile shading render pass

VUID-RuntimeSpirv-TileShadingQCOM-10701

A compute shader that enables SPIR-V capability TileShadingQCOMmust only be invoked inside those portions of a command buffer where per-tile execution model is enabled

VUID-RuntimeSpirv-x-10702

In compute shaders that enables SPIR-V capability TileShadingQCOM, the x size in TileShadingRateQCOM must be less than or equal to VkPhysicalDeviceTileShadingPropertiesQCOM::maxTileShadingRate::x

VUID-RuntimeSpirv-y-10703

In compute shaders that enables SPIR-V capability TileShadingQCOM, the y size in TileShadingRateQCOM must be less than or equal to VkPhysicalDeviceTileShadingPropertiesQCOM::maxTileShadingRate::y

VUID-RuntimeSpirv-z-10704

In compute shaders that enables SPIR-V capability TileShadingQCOM, the z size in TileShadingRateQCOM must be less than or equal to VkTilePropertiesQCOM::tileSize::z

VUID-RuntimeSpirv-tileSize-10705

In compute shaders that enables SPIR-V capability TileShadingQCOM, VkTilePropertiesQCOM::tileSize::z % TileShadingRateQCOM::z must equal 0

VUID-RuntimeSpirv-OpImage-10706

An OpImage with Storage Class TileAttachmentQCOMmust not be consumed by OpImageTexelPointer unless the tileShadingAtomicOps feature is enabled

VUID-RuntimeSpirv-OpTypeImage-10707

An OpTypeImage with Storage Class TileAttachmentQCOMmust not be backed by a view equivalent to the color attachment of the current subpass instance unless the tileShadingColorAttachments feature is enabled

VUID-RuntimeSpirv-OpTypeImage-10708

An OpTypeImage with Storage Class TileAttachmentQCOMmust not be backed by a view equivalent to the depth aspect of the depth/stencil attachment of the current subpass instance unless the tileShadingDepthAttachments

VUID-RuntimeSpirv-OpTypeImage-10709

An OpTypeImage with Storage Class TileAttachmentQCOMmust not be backed by a view equivalent to the stencil aspect of the depth/stencil attachment of the current subpass instance unless the tileShadingStencilAttachments feature is enabled

VUID-RuntimeSpirv-OpTypeImage-10710

An OpTypeImage with Storage Class TileAttachmentQCOMmust not be backed by a view equivalent to the input attachment of the current subpass instance unless the tileShadingInputAttachments feature is enabled

VUID-RuntimeSpirv-OpTypeSampledImage-10711

An OpTypeSampledImage with Storage Class

TileAttachmentQCOM must not be backed by a view equivalent to an attachment of the current subpass instance unless the tileShadingSampledAttachments feature is enabled

VUID-RuntimeSpirv-tileShadingImageProcessing-10712

If an OpTypeSampledImage with Storage Class

TileAttachmentQCOM is consumed by any argument of the following operations, tileShadingImageProcessingmust be enabled:

• OpImageSampleWeightedQCOM
• OpImageBoxFilterQCOM
• OpImageBlockMatch*QCOM ::

VUID-RuntimeSpirv-None-10715

If a VkSampler object that enables sampler Y′C_BC_R conversion is accessed in a shader, both the sampler and image accessed must be determined by constant integral expressions

VUID-RuntimeSpirv-None-10716

If a VkSampler object that enables sampler Y′C_BC_R conversion is statically used, it must only be used with OpImageSample* or OpImageSparseSample* instructions

VUID-RuntimeSpirv-OpImage-10717

An OpImage instruction must not be used on a VkSampler object that enables sampler Y′C_BC_R conversion

VUID-RuntimeSpirv-ConstOffset-10718

If a VkSampler object that enables sampler Y′C_BC_R conversion is statically used, it must not use the ConstOffset or Offset operands