From 50e1cf2c4e100d1e59f0db8a19e9d47c284d9126 Mon Sep 17 00:00:00 2001 From: Daniel Rakos Date: Thu, 19 Mar 2026 12:56:02 +0100 Subject: [PATCH] build: Prepare for release 1.0.21 --- CMakeLists.txt | 2 +- layers/VkSCLayer_khronos_validation.json.in | 2 +- layers/vulkansc/generated/enum_flag_bits.h | 2 +- .../generated/vk_validation_error_messages.h | 793 ++++++++++-------- scripts/known_good.json | 8 +- tests/icd/VVL_Test_ICD_vksc.json.in | 2 +- tests/vulkansc/device_profiles/max_core.json | 2 +- .../vulkansc/device_profiles/max_profile.json | 2 +- tests/vulkansc/device_profiles/min_core.json | 2 +- 9 files changed, 438 insertions(+), 377 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index a82598a93..c12941028 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -23,7 +23,7 @@ option(VULKANSC "Build Vulkan SC validation layers" ON) # # If working with unreleased extensions, make sure the header and validation version are all on the same header version if(VULKANSC) - project(VVL VERSION 1.0.20 LANGUAGES CXX) # vulkansc + project(VVL VERSION 1.0.21 LANGUAGES CXX) # vulkansc else() project(VVL VERSION 1.4.344 LANGUAGES CXX) # vulkan endif() diff --git a/layers/VkSCLayer_khronos_validation.json.in b/layers/VkSCLayer_khronos_validation.json.in index 793f34bcf..1e7534ce0 100644 --- a/layers/VkSCLayer_khronos_validation.json.in +++ b/layers/VkSCLayer_khronos_validation.json.in @@ -5,7 +5,7 @@ "prefix": "vvl", "type": "GLOBAL", "library_path": "@JSON_LIBRARY_PATH@", - "api_version": "1.0.20", + "api_version": "1.0.21", "implementation_version": "1", "description": "Khronos Validation Layer", "introduction": "The main, comprehensive Khronos validation layer.\n\nVulkan SC is an Explicit API, enabling direct control over how GPUs actually work. By design, minimal error checking is done inside a Vulkan SC driver. Applications have full control and responsibility for correct operation. Any errors in how Vulkan SC is used can result in a crash. \n\nThe Khronos Validation Layer can be enabled to assist development by enabling developers to verify their applications correctly use the Vulkan SC API.", diff --git a/layers/vulkansc/generated/enum_flag_bits.h b/layers/vulkansc/generated/enum_flag_bits.h index cf23470fd..06773d4e8 100644 --- a/layers/vulkansc/generated/enum_flag_bits.h +++ b/layers/vulkansc/generated/enum_flag_bits.h @@ -24,7 +24,7 @@ #include #include "vulkan/vulkan.h" // clang-format off -const uint32_t GeneratedVulkanHeaderVersion = 20; +const uint32_t GeneratedVulkanHeaderVersion = 21; const VkDeviceQueueCreateFlags AllVkDeviceQueueCreateFlagBits = VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT; const VkPipelineStageFlags AllVkPipelineStageFlagBits = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT|VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT|VK_PIPELINE_STAGE_VERTEX_INPUT_BIT|VK_PIPELINE_STAGE_VERTEX_SHADER_BIT|VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT|VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT|VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT|VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT|VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT|VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT|VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT|VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT|VK_PIPELINE_STAGE_TRANSFER_BIT|VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT|VK_PIPELINE_STAGE_HOST_BIT|VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT|VK_PIPELINE_STAGE_ALL_COMMANDS_BIT|VK_PIPELINE_STAGE_NONE|VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR; const VkImageAspectFlags AllVkImageAspectFlagBits = VK_IMAGE_ASPECT_COLOR_BIT|VK_IMAGE_ASPECT_DEPTH_BIT|VK_IMAGE_ASPECT_STENCIL_BIT|VK_IMAGE_ASPECT_METADATA_BIT|VK_IMAGE_ASPECT_PLANE_0_BIT|VK_IMAGE_ASPECT_PLANE_1_BIT|VK_IMAGE_ASPECT_PLANE_2_BIT|VK_IMAGE_ASPECT_NONE|VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT|VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT|VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT|VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT; diff --git a/layers/vulkansc/generated/vk_validation_error_messages.h b/layers/vulkansc/generated/vk_validation_error_messages.h index 2afeb21f2..41b1af3e3 100644 --- a/layers/vulkansc/generated/vk_validation_error_messages.h +++ b/layers/vulkansc/generated/vk_validation_error_messages.h @@ -1,6 +1,6 @@ // *** THIS FILE IS GENERATED - DO NOT EDIT *** // See generate_spec_error_message.py for modifications -// Based on Vulkan specification version: 1.0.20 +// Based on Vulkan specification version: 1.0.21 /*************************************************************************** * @@ -34,7 +34,7 @@ struct vuid_info { }; const vvl::unordered_map &GetVuidMap() { - static const std::array, 6173> vuid_array = {{ + static const std::array, 6234> vuid_array = {{ { {"VUID-BaseInstance-BaseInstance-04181", 36}, { {"The BaseInstance decoration must be used only within the Vertex Execution Model", 79}, { "chapters/interfaces.html", 24} } }, { {"VUID-BaseInstance-BaseInstance-04182", 36}, { {"The variable decorated with BaseInstance must be declared using the Input Storage Class", 87}, { "chapters/interfaces.html", 24} } }, { {"VUID-BaseInstance-BaseInstance-04183", 36}, { {"The variable decorated with BaseInstance must be declared as a scalar 32-bit integer value", 90}, { "chapters/interfaces.html", 24} } }, @@ -143,7 +143,8 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-10598", 58}, { {"PrimitiveShadingRateKHR within the MeshEXT Execution Model must decorate a scalar 32-bit integer member of a structure decorated as Block, or decorate a variable of type OpTypeArray of 32-bit integer values", 206}, { "chapters/interfaces.html", 24} } }, { {"VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-10599", 58}, { {"If PrimitiveShadingRateKHR is declared as an array of 32-bit integer values, within the MeshEXT Execution Model, size of the array must match the value specified by OutputPrimitivesEXT", 184}, { "chapters/interfaces.html", 24} } }, { {"VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-10600", 58}, { {"If PrimitiveShadingRateKHR decorates a member of a structure, the variable declaration of the containing Block type must have an array size that matches the value specified by OutputPrimitivesEXT", 195}, { "chapters/interfaces.html", 24} } }, - { {"VUID-RuntimeSpirv-ConstOffset-10718", 35}, { {"If a VkSampler object that enables sampler Y'CBCR conversion is statically used, it must not use the ConstOffset or Offset operands", 131}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-PrimitiveShadingRateKHR-PrimitiveShadingRateKHR-12275", 58}, { {"If PrimitiveShadingRateKHR is declared in the MeshEXT Execution Model, the primitiveFragmentShadingRateMeshShader feature must be enabled", 137}, { "chapters/interfaces.html", 24} } }, + { {"VUID-RuntimeSpirv-ConstOffset-10718", 35}, { {"If an OpTypeSampledImage variable backed by an image view and sampler that require sampler Y'CBCR conversion is statically used in a shader with a sampling instruction, it must not use the ConstOffset or Offset operands", 219}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-InputAttachmentArrayNonUniformIndexing-10138", 62}, { {"If the InputAttachmentArrayNonUniformIndexing capability is not declared, and an instruction accesses memory through an input attachment, the input attachment through which that memory is accessed must be dynamically uniform within the invocation group or subgroup", 264}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-LocalSizeId-06433", 35}, { {"The Execution Mode LocalSizeId must not be used", 47}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-Location-06272", 32}, { {"The sum of Location and the number of locations the variable it decorates consumes must be less than or equal to the value for the matching Execution Model defined in Shader Input and Output Locations", 200}, { "appendices/spirvenv.html", 24} } }, @@ -151,6 +152,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-RuntimeSpirv-MeshEXT-09218", 31}, { {"In mesh shaders using the MeshEXT or MeshNV Execution Model and the OutputPoints Execution Mode, if the number of output points is greater than 0, a PointSize decorated variable must be written to for each output point", 218}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-NonWritable-06340", 35}, { {"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", 202}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-NonWritable-06341", 35}, { {"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", 235}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-RuntimeSpirv-None-04745", 28}, { {"All block members in a variable with a Storage Class of PushConstant declared as an array must only be accessed by dynamically uniform indices", 142}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-None-06275", 28}, { {"shaderSubgroupExtendedTypes must be enabled for group operations to use 8-bit integer, 16-bit integer, 64-bit integer, 16-bit floating-point, and vectors of these types", 168}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-None-06284", 28}, { {"shaderBufferFloat32Atomics, or shaderBufferFloat32AtomicAdd, or shaderBufferFloat64Atomics, or shaderBufferFloat64AtomicAdd, must be enabled for floating-point atomic operations to be supported on a Pointer with a Storage Class of StorageBuffer", 244}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-None-06285", 28}, { {"shaderSharedFloat32Atomics, or shaderSharedFloat32AtomicAdd, or shaderSharedFloat64Atomics, or shaderSharedFloat64AtomicAdd, must be enabled for floating-point atomic operations to be supported on a Pointer with a Storage Class of Workgroup", 240}, { "appendices/spirvenv.html", 24} } }, @@ -163,11 +165,11 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-RuntimeSpirv-None-06343", 28}, { {"Group operations with subgroup scope must not be used if the shader stage is not in subgroupSupportedStages", 107}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-None-09558", 28}, { {"Any variable created with a \"Type\" of OpTypeImage that has a \"Dim\" operand of SubpassData must be decorated with InputAttachmentIndex", 137}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-None-10148", 28}, { {"If an instruction accesses memory through any resource, the effective subgroup size is 1, and the resource through which that memory is accessed is not uniform within the invocation group, then the operand corresponding to that resource (e.g. the pointer or sampled image operand) must be decorated with NonUniform", 314}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-RuntimeSpirv-None-10715", 28}, { {"If a VkSampler object that enables sampler Y'CBCR conversion is accessed in a shader, both the sampler and image accessed must be determined by constant integral expressions", 173}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-RuntimeSpirv-None-10716", 28}, { {"If a VkSampler object that enables sampler Y'CBCR conversion is statically used, it must only be used with OpImageSample* or OpImageSparseSample* instructions", 158}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-None-10824", 28}, { {"The Base operand of any OpBitCount, OpBitReverse, OpBitFieldInsert, OpBitFieldSExtract, or OpBitFieldUExtract instruction must be a 32-bit integer scalar or a vector of 32-bit integers", 184}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-None-10834", 28}, { {"Buffer indexing calculations must not wrap 32 bits", 50}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-None-10980", 28}, { {"Objects containing 8-bit integer or 8-bit floating-point elements must not have storage class of Input or Output", 112}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-RuntimeSpirv-None-12205", 28}, { {"If an image view or sampler that requires sampler Y'CBCR conversion is accessed in a shader, it must be determined by constant integral expressions", 147}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-RuntimeSpirv-None-12295", 28}, { {"the Component Count of any vector type must be less than or equal to 4 and greater than 1", 89}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-Offset-06344", 30}, { {"The first element of the Offset operand of InterpolateAtOffset must be greater than or equal to: fragwidth x minInterpolationOffset where fragwidth is the width of the current fragment in pixels", 194}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-Offset-06345", 30}, { {"The first element of the Offset operand of InterpolateAtOffset must be less than or equal to fragwidth x (maxInterpolationOffset + ULP ) - ULP where fragwidth is the width of the current fragment in pixels and ULP = 1 / 2^subPixelInterpolationOffsetBits^", 254}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-Offset-06346", 30}, { {"The second element of the Offset operand of InterpolateAtOffset must be greater than or equal to fragheight x minInterpolationOffset where fragheight is the height of the current fragment in pixels", 197}, { "appendices/spirvenv.html", 24} } }, @@ -180,16 +182,20 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-RuntimeSpirv-OpEntryPoint-08743", 36}, { {"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", 294}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpImage-06376", 31}, { {"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", 162}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpImage-06377", 31}, { {"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", 159}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-RuntimeSpirv-OpImage-10717", 31}, { {"An OpImage instruction must not be used on a VkSampler object that enables sampler Y'CBCR conversion", 100}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpImageSample-06435", 37}, { {"If an OpImageSample* or OpImageFetch* operation has an image operand of ConstOffset then the offset value must be greater than or equal to minTexelOffset", 153}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpImageSample-06436", 37}, { {"If an OpImageSample* or OpImageFetch* operation has an image operand of ConstOffset then the offset value must be less than or equal to maxTexelOffset", 150}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpImageWrite-07112", 36}, { {"OpImageWrite to any Image whose Image Format is not Unknown must have the Texel operand contain at least as many components as the corresponding VkFormat as given in the SPIR-V Image Format compatibility table", 209}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpTypeImage-06269", 35}, { {"If the shaderStorageImageWriteWithoutFormat feature is not enabled, any variable created with a \"Type\" of OpTypeImage that has a \"Sampled\" operand of 2 and an \"Image Format\" operand of Unknown must be decorated with NonWritable", 233}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpTypeImage-06270", 35}, { {"If the shaderStorageImageReadWithoutFormat feature is not enabled, any variable created with a \"Type\" of OpTypeImage that has a \"Sampled\" operand of 2 and an \"Image Format\" operand of Unknown must be decorated with NonReadable", 232}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-RuntimeSpirv-OpTypeVector-06816", 36}, { {"Any OpTypeVector output interface variables must not have a higher Component Count than a matching OpTypeVector input interface variable", 136}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-RuntimeSpirv-OpTypeImage-12204", 35}, { {"If a variable with type OpTypeImage is declared in the Shader Resource Interface, it must not be backed by an image view that requires sampler Y'CBCR conversion", 160}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-RuntimeSpirv-OpTypeImage-12207", 35}, { {"If a OpTypeImage variable backed by an image view that requires sampler Y'CBCR conversion is statically used in a shader, it must only be used with OpImageQueryLevels or OpImageQuerySizeLod instructions", 202}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-RuntimeSpirv-OpTypeSampledImage-12206", 42}, { {"If an OpTypeSampledImage variable backed by an image view and sampler that require sampler Y'CBCR conversion is statically used in a shader, it must only be used with OpImageSample*, OpImageSparseSample*, or OpImage instructions", 228}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-RuntimeSpirv-OpTypeSampler-12203", 37}, { {"If a variable with type OpTypeSampler is declared in the Shader Resource Interface, it must not be backed by a sampler that requires sampler Y'CBCR conversion", 158}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-RuntimeSpirv-OpTypeVector-06816", 36}, { {"Any vector type output interface variables must not have a higher Component Count than a matching vector type input interface variable", 134}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpVariable-06373", 34}, { {"Any variable with Workgroup as its Storage Class must not have an Initializer operand", 85}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-OpVariable-08746", 34}, { {"Any variable, 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", 200}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-PhysicalStorageBuffer64-06315", 47}, { {"If the PhysicalStorageBuffer64 addressing model is enabled the pointer value of a memory access instruction must be at least as aligned as specified by the Aligned memory access operand", 185}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-RuntimeSpirv-PhysicalStorageBuffer64-11819", 47}, { {"If the PhysicalStorageBuffer64 addressing model is enabled the pointer value of a memory access instruction in the PhysicalStorageBuffer Storage Class must reference a buffer created with the VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT usage flag set", 248}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-SampledImageArrayNonUniformIndexing-10135", 59}, { {"If the SampledImageArrayNonUniformIndexing capability is not declared, and an instruction accesses memory through a sampled image or sampler, the sampled image or sampler through which that memory is accessed must be dynamically uniform within the invocation group or subgroup", 276}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-StorageBufferArrayNonUniformIndexing-10136", 60}, { {"If the StorageBufferArrayNonUniformIndexing capability is not declared, and an instruction accesses memory through a storage buffer, the storage buffer through which that memory is accessed must be dynamically uniform within the invocation group or subgroup", 257}, { "appendices/spirvenv.html", 24} } }, { {"VUID-RuntimeSpirv-StorageImageArrayNonUniformIndexing-10137", 59}, { {"If the StorageImageArrayNonUniformIndexing capability is not declared, and an instruction accesses memory through a storage image, the storage image through which that memory is accessed must be dynamically uniform within the invocation group or subgroup", 254}, { "appendices/spirvenv.html", 24} } }, @@ -255,8 +261,8 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-StandaloneSpirv-BuiltIn-04668", 34}, { {"Any BuiltIn decoration not listed in Built-In Variables must not be used", 72}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-CallableDataKHR-04704", 42}, { {"CallableDataKHR Storage Class must only be used in ray generation, closest hit, miss, and callable shaders", 106}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Component-04920", 36}, { {"The Component decoration value must not be greater than 3", 57}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-Component-04921", 36}, { {"If the Component decoration is used on a variable that has a OpTypeVector type with a Component Type with a Width that is less than or equal to 32, the sum of its Component Count and the Component decoration value must be less than or equal to 4", 245}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-Component-04922", 36}, { {"If the Component decoration is used on a variable that has a OpTypeVector type with a Component Type with a Width that is equal to 64, the sum of two times its Component Count and the Component decoration value must be less than or equal to 4", 242}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-Component-04921", 36}, { {"If the Component decoration is used on a variable that has a vector type with a Component Type with a Width that is less than or equal to 32, the sum of its Component Count and the Component decoration value must be less than or equal to 4", 239}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-Component-04922", 36}, { {"If the Component decoration is used on a variable that has a vector type with a Component Type with a Width that is equal to 64, the sum of two times its Component Count and the Component decoration value must be less than or equal to 4", 236}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Component-04923", 36}, { {"The Component decorations value must not be 1 or 3 for scalar or two-component 64-bit data types", 96}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Component-07703", 36}, { {"The Component decorations must not be used for a 64-bit vector type with more than two components", 97}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Component-10583", 36}, { {"The Component decorations must not be used with any type that is not a scalar, vector, array of scalars or vectors, or an array of arrays of scalars or vectors", 159}, { "appendices/spirvenv.html", 24} } }, @@ -264,6 +270,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-StandaloneSpirv-DerivativeGroupLinearNV-04778", 50}, { {"For compute shaders using the DerivativeGroupLinearNV execution mode, the product of the dimensions of the local workgroup size must be a multiple of four", 154}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-DerivativeGroupQuadsKHR-10151", 50}, { {"For compute, mesh, or task shaders using the DerivativeGroupQuadsKHR execution mode, the first two dimensions of the local workgroup size must be a multiple of two", 163}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-DerivativeGroupQuadsNV-04684", 49}, { {"For compute shaders using the DerivativeGroupQuadsNV execution mode, the first two dimensions of the local workgroup size must be a multiple of two", 147}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-DescriptorHeapEXT-11482", 44}, { {"If the DescriptorHeapEXT capability is declared, structure types must not contain opaque types other than descriptors", 117}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-DescriptorSet-06491", 40}, { {"If a variable is decorated by DescriptorSet or Binding, the Storage Class must correspond to an entry in Shader Resource and Storage Class Correspondence", 153}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Execution-10584", 36}, { {"If the Execution Model of an entry point is not TessellationControl or Geometry, its interface definition must not include any variables in the Input storage class decorated with Component that are arrays of arrays of scalars or vectors", 236}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Execution-10585", 36}, { {"If the Execution Model of an entry point is not MeshNV, its interface definition must not include any variables in the Output storage class decorated with Component that are arrays of arrays of scalars or vectors", 212}, { "appendices/spirvenv.html", 24} } }, @@ -276,6 +283,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-StandaloneSpirv-Flat-06201", 31}, { {"The Flat, NoPerspective, Sample, and Centroid decorations must not be used on variables with the Output storage class in a fragment shader", 138}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Flat-06202", 31}, { {"The Flat, NoPerspective, Sample, and Centroid decorations must not be used on variables with the Input storage class in a vertex shader", 135}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Function-04681", 35}, { {"A type T that is an array sized with a specialization constant must neither be, nor be contained in, the type T2 of a variable V, unless either: a) T is equal to T2, b) V is declared in the Function, or Private Storage Class, c) V is a non-Block variable in the Workgroup Storage Class, or d) V is an interface variable with an additional level of arrayness, as described in interface matching, and T is the member type of the array type T2", 440}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-Function-12294", 35}, { {"A type T that is a vector sized with a specialization constant must neither be, nor be contained in, the type T2 of a variable V, unless either: a) T is equal to T2, b) V is declared in the Function, or Private Storage Class, c) V is a non-Block variable in the Workgroup Storage Class, or d) V is an interface variable with an additional level of arrayness, as described in interface matching, and T is the member type of the array type T2", 440}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-GLSLShared-04669", 37}, { {"The GLSLShared and GLSLPacked decorations must not be used", 58}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-HitAttributeKHR-04701", 42}, { {"HitAttributeKHR Storage Class must only be used in intersection, any-hit, or closest hit shaders", 96}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-HitAttributeKHR-04702", 42}, { {"There must be at most one variable with the HitAttributeKHR Storage Class in the input interface of an entry point", 114}, { "appendices/spirvenv.html", 24} } }, @@ -311,7 +319,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-StandaloneSpirv-MemorySemantics-10874", 42}, { {"MemorySemantics with Volatile bit set must not be used with barrier instructions (OpControlBarrier or OpMemoryBarrier)", 118}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-MeshEXT-07102", 34}, { {"The module must not contain both an entry point that uses the TaskEXT or MeshEXT Execution Model and an entry point that uses the TaskNV or MeshNV Execution Model", 162}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-MeshEXT-07106", 34}, { {"In mesh shaders using the MeshEXT Execution Model OpSetMeshOutputsEXT must be called before any outputs are written", 115}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-MeshEXT-07107", 34}, { {"In mesh shaders using the MeshEXT Execution Model all variables declared as output must not be read from", 104}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-MeshEXT-07107", 34}, { {"In mesh shaders using the MeshEXT Execution Model all variables declared in the Output Storage Class must not be read", 117}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-MeshEXT-07108", 34}, { {"In mesh shaders using the MeshEXT Execution Model for OpSetMeshOutputsEXT instructions, the \"Vertex Count\" and \"Primitive Count\" operands must not depend on ViewIndex", 170}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-MeshEXT-07109", 34}, { {"In mesh shaders using the MeshEXT Execution Model variables decorated with PrimitivePointIndicesEXT, PrimitiveLineIndicesEXT, or PrimitiveTriangleIndicesEXT declared as an array must not be accessed by indices that depend on ViewIndex", 234}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-MeshEXT-07110", 34}, { {"In mesh shaders using the MeshEXT Execution Model any values stored in variables decorated with PrimitivePointIndicesEXT, PrimitiveLineIndicesEXT, or PrimitiveTriangleIndicesEXT must not depend on ViewIndex", 206}, { "appendices/spirvenv.html", 24} } }, @@ -331,24 +339,23 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-StandaloneSpirv-None-04643", 31}, { {"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", 298}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-None-04644", 31}, { {"If the Storage Class is Output, then it must not be used in the GlCompute, RayGenerationKHR, IntersectionKHR, AnyHitKHR, ClosestHitKHR, MissKHR, or CallableKHR Execution Model", 175}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-None-04645", 31}, { {"If the Storage Class is Workgroup, then it must only be used in the task, mesh, or compute Execution Model", 106}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-None-04667", 31}, { {"Structure types must not contain opaque types", 45}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-None-04667", 31}, { {"If the DescriptorHeapEXT capability is not declared, structure types must not contain opaque types", 98}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-None-04686", 31}, { {"The Pointer operand of all atomic instructions must have a Storage Class limited to Uniform, Workgroup, Image, StorageBuffer, PhysicalStorageBuffer, or TaskPayloadWorkgroupEXT", 175}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-None-04745", 31}, { {"All block members in a variable with a Storage Class of PushConstant declared as an array must only be accessed by dynamically uniform indices", 142}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-None-07321", 31}, { {"If the Scope for memory is Workgroup, then it must only be used in the task, mesh, tessellation control, or compute Execution Model", 131}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-None-08720", 31}, { {"If the Storage Class is TileImageEXT, then it must only be used in the fragment execution model", 95}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-None-08724", 31}, { {"The TileImageEXT Storage Class must only be used for declaring tile image variables", 83}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-None-10684", 31}, { {"All variables must have valid explicit layout decorations as described in Shader Interfaces", 91}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-None-10685", 31}, { {"For each compute shader entry point, either a TileShadingRateQCOM, LocalSize, or LocalSizeId Execution Mode, or an object decorated with the WorkgroupSize decoration must be specified", 183}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-None-10685", 31}, { {"Either a TileShadingRateQCOM, LocalSize, or LocalSizeId Execution Mode, or an object decorated with the WorkgroupSize decoration must be specified for each entry point with a task, mesh, or compute Execution Model", 213}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Offset-04687", 33}, { {"Output variables or block members decorated with Offset that have a 64-bit type, or a composite type containing a 64-bit type, must specify an Offset value aligned to a 8 byte boundary", 184}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Offset-04689", 33}, { {"The size of any output block containing any member decorated with Offset that is a 64-bit type must be a multiple of 8", 118}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Offset-04690", 33}, { {"The first member of an output block specifying a Offset decoration must specify a Offset value that is aligned to an 8 byte boundary if that block contains any member decorated with Offset and is a 64-bit type", 209}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Offset-04691", 33}, { {"Output variables or block members decorated with Offset that have a 32-bit type, or a composite type contains a 32-bit type, must specify an Offset value aligned to a 4 byte boundary", 182}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-Offset-04692", 33}, { {"Output variables, blocks or block members decorated with Offset must only contain base types that have components that are either 32-bit or 64-bit in size", 154}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-Offset-04692", 33}, { {"Output variables, blocks, or block members decorated with Offset must only contain base types that have components that are either 32-bit or 64-bit in size", 155}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Offset-04716", 33}, { {"Only variables or block members in the output interface decorated with Offset can be captured for transform feedback, and those variables or block members must also be decorated with XfbBuffer and XfbStride, or inherit XfbBuffer and XfbStride decorations from a block containing them", 283}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Offset-04865", 33}, { {"Any image instruction which uses an Offset, ConstOffset, or ConstOffsets image operand, must only consume a \"Sampled Image\" operand whose type has its \"Sampled\" operand set to 1", 181}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-OpArrayLength-11805", 40}, { {"OpArrayLength must not be used with an OpTypeRuntimeArray that is the last member of a Block-decorated OpTypeStruct in the Uniform storage Storage Class", 152}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-OpArrayLength-11805", 40}, { {"OpArrayLength and OpUntypedArrayLengthKHR must not be used with an OpTypeRuntimeArray that is the last member of a Block-decorated OpTypeStruct in the Uniform storage Storage Class", 180}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpControlBarrier-04682", 43}, { {"If OpControlBarrier is used in ray generation, intersection, any-hit, closest hit, miss, fragment, vertex, tessellation evaluation, or geometry shaders, the execution Scope must be Subgroup", 189}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-OpEntryPoint-06674", 39}, { {"Each OpEntryPoint must not statically use more than one variable in the PushConstant Storage Class", 98}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-OpEntryPoint-06674", 39}, { {"Each OpEntryPoint must statically use at most one variable in the PushConstant Storage Class unless the PushConstantBanksNV capability is declared", 146}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpEntryPoint-08721", 39}, { {"Each OpEntryPoint must not have more than one Input variable assigned the same Component word inside a Location slot, either explicitly or implicitly", 149}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpEntryPoint-08722", 39}, { {"Each OpEntryPoint must not have more than one Output variable assigned the same Component word inside a Location slot, either explicitly or implicitly", 150}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpEntryPoint-09658", 39}, { {"For a given OpEntryPoint, any BuiltIn decoration must not be used more than once by the Input interface", 103}, { "appendices/spirvenv.html", 24} } }, @@ -371,12 +378,15 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-StandaloneSpirv-OpTypeImage-09638", 38}, { {"An OpTypeImage must not have a \"Dim\" operand of Rect", 54}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpTypeImage-10693", 38}, { {"OpTypeImage variables in the TileAttachmentQCOM Storage Class must have Dim equal to 2D", 87}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpTypeImage-10694", 38}, { {"OpTypeImage variables in the TileAttachmentQCOM Storage Class must Sampled equal to 1 or 2", 90}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-OpTypeRuntimeArray-04680", 45}, { {"OpTypeRuntimeArray must only be instantiated by a variable as: the last member of a Block-decorated OpTypeStruct in StorageBuffer or PhysicalStorageBuffer storage Storage Class BufferBlock-decorated OpTypeStruct in the Uniform storage Storage Class the outermost dimension of an arrayed variable in the StorageBuffer, Uniform, or UniformConstant storage Storage Class the NodePayloadAMDX storage Storage Class when the CoalescingAMDX Execution Mode is specified", 461}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-OpTypeRuntimeArray-04680", 45}, { {"OpTypeRuntimeArray must only be instantiated by a variable as: the last member of a Block-decorated OpTypeStruct in StorageBuffer or PhysicalStorageBuffer storage Storage Class BufferBlock-decorated OpTypeStruct in the Uniform storage Storage Class the last member of a Block-decorated OpTypeStruct in the Uniform storage Storage Class the outermost dimension of an arrayed variable in the StorageBuffer, Uniform, or UniformConstant storage Storage Class the NodePayloadAMDX storage Storage Class when the CoalescingAMDX Execution Mode is specified", 548}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpTypeSampledImage-06671", 45}, { {"OpTypeSampledImage must have a OpTypeImage with a \"Sampled\" operand of 1 (sampled image)", 90}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-OpUntypedVariableKHR-11167", 47}, { {"Any OpUntypedVariableKHR must have a Data Type operand specified", 64}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-OpTypeUntypedPointerKHR-11417", 50}, { {"The Storage Class of OpTypeUntypedPointerKHR must be Image, UniformConstant,Workgroup, StorageBuffer, Uniform, PushConstant, or PhysicalStorageBuffer", 149}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-OpUntypedImageTexelPointerEXT-11416", 56}, { {"If an OpUntypedImageTexelPointerEXT instruction is used in an atomic operation, the image type operand must have an image format of R64i, R64ui, R32f, R32i, or R32ui", 165}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-OpUntypedVariableKHR-11167", 47}, { {"Any OpUntypedVariableKHR with a Storage Class other than UniformConstant must have a Data Type operand specified", 112}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-OpUntypedVariableKHR-11347", 47}, { {"Any OpUntypedVariableKHR in the UniformConstant storage class without a Data Type must be decorated with SamplerHeapEXT or ResourceHeapEXT", 138}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpVariable-04651", 37}, { {"Any variable with an Initializer operand must have Output, Private, Function, or Workgroup as its Storage Class operand", 119}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OpVariable-04734", 37}, { {"Any variable with an Initializer operand and Workgroup as its Storage Class operand must use OpConstantNull as the initializer", 126}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-OpVariable-06673", 37}, { {"There must not be more than one variable in the PushConstant Storage Class listed in the Interface for each OpEntryPoint", 120}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-OpVariable-06673", 37}, { {"There must be at most one variable in the PushConstant Storage Class listed in the Interface for each OpEntryPoint unless the PushConstantBanksNV capability is declared", 168}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-OriginLowerLeft-04653", 42}, { {"The OriginLowerLeft Execution Mode must not be used; fragment entry points must declare OriginUpperLeft", 103}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Output-10586", 33}, { {"Variables in the Output storage class in the Vertex, TessellationControl, TessellationEvaluation, or Geometry execution model must not have overlapping Component and Location decorations as defined by Location and Component Assignment", 234}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Output-10587", 33}, { {"Variables in the Output storage class in the Fragment execution model must not have both identical Index decorations and overlapping Component and Location decorations as defined by Location and Component Assignment", 215}, { "appendices/spirvenv.html", 24} } }, @@ -391,7 +401,12 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-StandaloneSpirv-PushConstant-06808", 39}, { {"Any variable in the PushConstant Storage Class must be typed as OpTypeStruct", 76}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-RayPayloadKHR-04698", 40}, { {"RayPayloadKHR Storage Class must only be used in ray generation, closest hit or miss shaders", 92}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-Result-04780", 33}, { {"The Result Type operand of any OpImageRead or OpImageSparseRead instruction must be a vector of four components", 111}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-Result-11336", 33}, { {"If the Result Type operand of OpLoad is OpTypeSampler, Pointer must be derived from a variable decorated with Binding and DescriptorSet, or decorated with BuiltIn and SamplerHeapEXT", 181}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-Result-11337", 33}, { {"If the Result Type operand of OpLoad is OpTypeImage, Pointer must be derived from a variable decorated with Binding and DescriptorSet, or decorated with BuiltIn and ResourceHeapEXT", 180}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-Result-11339", 33}, { {"If the Result Type operand of OpLoad is OpTypeAccelerationStructureKHR, and Pointer is not in the Private or Function Storage Class, Pointer must be derived from a variable decorated with Binding and DescriptorSet, or decorated with BuiltIn and ResourceHeapEXT", 260}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-Result-11346", 33}, { {"The Result Type operand of OpBufferPointerEXT must have a Type operand that is explicitly laid out", 98}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-SampledImageArrayDynamicIndexing-10128", 59}, { {"If the SampledImageArrayDynamicIndexing capability is not declared, and an instruction accesses memory through a sampled image or sampler, the sampled image or sampler through which that memory is accessed must be determined by constant integral expressions", 257}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-Scope-12243", 32}, { {"The Scope operand of OpTypeCooperativeMatrixKHR must be limited to Workgroup or Subgroup", 88}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-ShaderRecordBufferKHR-07119", 48}, { {"ShaderRecordBufferKHR Storage Class must only be used in ray generation, intersection, any-hit, closest hit, callable, or miss shaders", 134}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-StorageBufferArrayDynamicIndexing-10129", 60}, { {"If the StorageBufferArrayDynamicIndexing capability is not declared, and an instruction accesses memory through a storage buffer, the storage buffer through which that memory is accessed must be determined by constant integral expressions", 238}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-StorageImageArrayDynamicIndexing-10130", 59}, { {"If the StorageImageArrayDynamicIndexing capability is not declared, and an instruction accesses memory through a storage image, the storage image through which that memory is accessed must be determined by constant integral expressions", 235}, { "appendices/spirvenv.html", 24} } }, @@ -418,7 +433,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-StandaloneSpirv-Uniform-06925", 34}, { {"Any variable in the Uniform Storage Class decorated as Block must not be stored to or modified", 94}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-UniformBufferArrayDynamicIndexing-10127", 60}, { {"If the UniformBufferArrayDynamicIndexing capability is not declared, and an instruction accesses memory through a uniform buffer, the uniform buffer through which that memory is accessed must be determined by constant integral expressions", 238}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-UniformConstant-04655", 42}, { {"Any variable in the UniformConstant Storage Class must be typed as either OpTypeImage, OpTypeSampler, OpTypeSampledImage, OpTypeAccelerationStructureKHR, OpTypeTensorARM or an array of one of these types", 203}, { "appendices/spirvenv.html", 24} } }, - { {"VUID-StandaloneSpirv-UniformConstant-06677", 42}, { {"Any variable in the UniformConstant, StorageBuffer, or Uniform Storage Class must be decorated with DescriptorSet and Binding", 125}, { "appendices/spirvenv.html", 24} } }, + { {"VUID-StandaloneSpirv-UniformConstant-06677", 42}, { {"Any variable in the UniformConstant, StorageBuffer, or Uniform Storage Class must be decorated with DescriptorSet, Binding, or BuiltIn with SamplerHeapEXT or ResourceHeapEXT", 173}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-UniformTexelBufferArrayDynamicIndexing-10132", 65}, { {"If the UniformTexelBufferArrayDynamicIndexing capability is not declared, and an instruction accesses memory through a uniform texel buffer, the uniform texel buffer through which that memory is accessed must be determined by constant integral expressions", 255}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-ViewportMaskNV-04674", 41}, { {"The ViewportMaskNV and ViewportIndex decorations must not both be statically used by one or more OpEntryPoint's that form the pre-rasterization shader stages of a graphics pipeline", 180}, { "appendices/spirvenv.html", 24} } }, { {"VUID-StandaloneSpirv-ViewportRelativeNV-04672", 45}, { {"The ViewportRelativeNV decoration must only be used on a variable decorated with Layer in the vertex, tessellation evaluation, or geometry shader stages", 152}, { "appendices/spirvenv.html", 24} } }, @@ -603,7 +618,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkBindBufferMemoryInfo-buffer-01444", 40}, { {"If buffer requires a dedicated allocation (as reported by vkGetBufferMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for buffer), memory must have been allocated with VkMemoryDedicatedAllocateInfo::buffer equal to buffer", 254}, { "chapters/resources.html", 23} } }, { {"VUID-VkBindBufferMemoryInfo-buffer-07459", 40}, { {"buffer must not have been bound to a memory object", 50}, { "chapters/resources.html", 23} } }, { {"VUID-VkBindBufferMemoryInfo-buffer-parameter", 44}, { {"buffer must be a valid VkBuffer handle", 38}, { "chapters/resources.html", 23} } }, - { {"VUID-VkBindBufferMemoryInfo-bufferDeviceAddress-03339", 53}, { {"If the VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress feature is enabled and buffer was created with the VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT bit set, memory must have been allocated with the VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT bit set", 260}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBindBufferMemoryInfo-bufferDeviceAddress-03339", 53}, { {"If the VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress feature is enabled and buffer was created with the VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT usage flag set, memory must have been allocated with the VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT bit set", 267}, { "chapters/resources.html", 23} } }, { {"VUID-VkBindBufferMemoryInfo-bufferDeviceAddressCaptureReplay-09200", 66}, { {"If the VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddressCaptureReplay feature is enabled and buffer was created with the VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT bit set, memory must have been allocated with the VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT bit set", 297}, { "chapters/resources.html", 23} } }, { {"VUID-VkBindBufferMemoryInfo-commonparent", 40}, { {"Both of buffer, and memory must have been created, allocated, or retrieved from the same VkDevice", 97}, { "chapters/resources.html", 23} } }, { {"VUID-VkBindBufferMemoryInfo-memory-01035", 40}, { {"memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer", 202}, { "chapters/resources.html", 23} } }, @@ -637,9 +652,9 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkBindImageMemoryInfo-memory-02989", 39}, { {"If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created", 194}, { "chapters/resources.html", 23} } }, { {"VUID-VkBindImageMemoryInfo-memory-10926", 39}, { {"If the VkMemoryAllocateInfo provided when memory was allocated included a VkMemoryDedicatedAllocateInfo structure in its pNext chain, VkMemoryDedicatedAllocateInfo::buffer must have been VK_NULL_HANDLE", 201}, { "chapters/resources.html", 23} } }, { {"VUID-VkBindImageMemoryInfo-memoryOffset-01046", 45}, { {"memoryOffset must be less than the size of memory", 49}, { "chapters/resources.html", 23} } }, - { {"VUID-VkBindImageMemoryInfo-pNext-01615", 38}, { {"If the pNext chain does not include a VkBindImagePlaneMemoryInfo structure, memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image", 277}, { "chapters/resources.html", 23} } }, - { {"VUID-VkBindImageMemoryInfo-pNext-01616", 38}, { {"If the pNext chain does not include a VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image", 243}, { "chapters/resources.html", 23} } }, - { {"VUID-VkBindImageMemoryInfo-pNext-01617", 38}, { {"If the pNext chain does not include a VkBindImagePlaneMemoryInfo structure, the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image", 290}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBindImageMemoryInfo-pNext-01615", 38}, { {"If the pNext chain does not include a VkBindImagePlaneMemoryInfo structure, then memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image", 282}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBindImageMemoryInfo-pNext-01616", 38}, { {"If the pNext chain does not include a VkBindImagePlaneMemoryInfo structure, then memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image", 248}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBindImageMemoryInfo-pNext-01617", 38}, { {"If the pNext chain does not include a VkBindImagePlaneMemoryInfo structure, then the difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with the same image", 295}, { "chapters/resources.html", 23} } }, { {"VUID-VkBindImageMemoryInfo-pNext-01618", 38}, { {"If the pNext chain includes a VkBindImagePlaneMemoryInfo structure, image must have been created with the VK_IMAGE_CREATE_DISJOINT_BIT bit set", 142}, { "chapters/resources.html", 23} } }, { {"VUID-VkBindImageMemoryInfo-pNext-01619", 38}, { {"If the pNext chain includes a VkBindImagePlaneMemoryInfo structure, memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image and where VkBindImagePlaneMemoryInfo::planeAspect corresponds to the VkImagePlaneMemoryRequirementsInfo::planeAspect in the VkImageMemoryRequirementsInfo2 structure's pNext chain", 448}, { "chapters/resources.html", 23} } }, { {"VUID-VkBindImageMemoryInfo-pNext-01620", 38}, { {"If the pNext chain includes a VkBindImagePlaneMemoryInfo structure, memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image and where VkBindImagePlaneMemoryInfo::planeAspect corresponds to the VkImagePlaneMemoryRequirementsInfo::planeAspect in the VkImageMemoryRequirementsInfo2 structure's pNext chain", 414}, { "chapters/resources.html", 23} } }, @@ -660,7 +675,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkBlitImageInfo2-aspectMask-00241", 38}, { {"For each element of pRegions, srcSubresource.aspectMask must specify aspects present in srcImage", 96}, { "chapters/copies.html", 20} } }, { {"VUID-VkBlitImageInfo2-aspectMask-00242", 38}, { {"For each element of pRegions, dstSubresource.aspectMask must specify aspects present in dstImage", 96}, { "chapters/copies.html", 20} } }, { {"VUID-VkBlitImageInfo2-commonparent", 34}, { {"Both of dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice", 101}, { "chapters/copies.html", 20} } }, - { {"VUID-VkBlitImageInfo2-dstImage-00224", 36}, { {"dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag", 79}, { "chapters/copies.html", 20} } }, + { {"VUID-VkBlitImageInfo2-dstImage-00224", 36}, { {"dstImage must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 87}, { "chapters/copies.html", 20} } }, { {"VUID-VkBlitImageInfo2-dstImage-00225", 36}, { {"If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 109}, { "chapters/copies.html", 20} } }, { {"VUID-VkBlitImageInfo2-dstImage-00234", 36}, { {"dstImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT", 77}, { "chapters/copies.html", 20} } }, { {"VUID-VkBlitImageInfo2-dstImage-00250", 36}, { {"If dstImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, dstOffsets[0].y must be 0 and dstOffsets[1].y must be 1", 131}, { "chapters/copies.html", 20} } }, @@ -685,7 +700,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkBlitImageInfo2-pRegions-parameter", 40}, { {"pRegions must be a valid pointer to an array of regionCount valid VkImageBlit2 structures", 89}, { "chapters/copies.html", 20} } }, { {"VUID-VkBlitImageInfo2-regionCount-arraylength", 45}, { {"regionCount must be greater than 0", 34}, { "chapters/copies.html", 20} } }, { {"VUID-VkBlitImageInfo2-sType-sType", 33}, { {"sType must be VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2", 49}, { "chapters/copies.html", 20} } }, - { {"VUID-VkBlitImageInfo2-srcImage-00219", 36}, { {"srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag", 79}, { "chapters/copies.html", 20} } }, + { {"VUID-VkBlitImageInfo2-srcImage-00219", 36}, { {"srcImage must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 87}, { "chapters/copies.html", 20} } }, { {"VUID-VkBlitImageInfo2-srcImage-00220", 36}, { {"If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 109}, { "chapters/copies.html", 20} } }, { {"VUID-VkBlitImageInfo2-srcImage-00229", 36}, { {"If either of srcImage or dstImage was created with a signed integer VkFormat, the other must also have been created with a signed integer VkFormat", 146}, { "chapters/copies.html", 20} } }, { {"VUID-VkBlitImageInfo2-srcImage-00230", 36}, { {"If either of srcImage or dstImage was created with an unsigned integer VkFormat, the other must also have been created with an unsigned integer VkFormat", 152}, { "chapters/copies.html", 20} } }, @@ -718,7 +733,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkBufferCreateInfo-flags-00917", 35}, { {"flags must not contain VK_BUFFER_CREATE_SPARSE_ALIASED_BIT", 58}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferCreateInfo-flags-01887", 35}, { {"If the protectedMemory feature is not enabled, flags must not contain VK_BUFFER_CREATE_PROTECTED_BIT", 100}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferCreateInfo-flags-03338", 35}, { {"If flags includes VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, the bufferDeviceAddressCaptureReplay feature must be enabled", 130}, { "chapters/resources.html", 23} } }, - { {"VUID-VkBufferCreateInfo-flags-09641", 35}, { {"If flags includes VK_BUFFER_CREATE_PROTECTED_BIT, then usage must not contain any of the following bits", 103}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBufferCreateInfo-flags-09641", 35}, { {"If flags includes VK_BUFFER_CREATE_PROTECTED_BIT, then the effective usage must not contain bits other than VK_BUFFER_USAGE_TRANSFER_SRC_BIT VK_BUFFER_USAGE_TRANSFER_DST_BIT VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT VK_BUFFER_USAGE_STORAGE_BUFFER_BIT VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT", 367}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferCreateInfo-flags-parameter", 39}, { {"flags must be a valid combination of VkBufferCreateFlagBits values", 66}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferCreateInfo-opaqueCaptureAddress-03337", 50}, { {"If VkBufferOpaqueCaptureAddressCreateInfo::opaqueCaptureAddress is not zero, flags must include VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT", 146}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferCreateInfo-pNext-00920", 35}, { {"If the pNext chain includes a VkExternalMemoryBufferCreateInfo structure, its handleTypes member must only contain bits that are also in VkExternalBufferProperties::externalMemoryProperties.compatibleHandleTypes, as returned by vkGetPhysicalDeviceExternalBufferProperties with pExternalBufferInfo->handleType equal to any one of the handle types specified in VkExternalMemoryBufferCreateInfo::handleTypes", 404}, { "chapters/resources.html", 23} } }, @@ -730,7 +745,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkBufferCreateInfo-sharingMode-01419", 41}, { {"If sharingMode is VK_SHARING_MODE_CONCURRENT, each element of pQueueFamilyIndices must be unique and must be less than pQueueFamilyPropertyCount returned by either vkGetPhysicalDeviceQueueFamilyProperties2 or vkGetPhysicalDeviceQueueFamilyProperties for the physicalDevice that was used to create device", 303}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferCreateInfo-sharingMode-parameter", 45}, { {"sharingMode must be a valid VkSharingMode value", 47}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferCreateInfo-size-00912", 34}, { {"size must be greater than 0", 27}, { "chapters/resources.html", 23} } }, - { {"VUID-VkBufferDeviceAddressInfo-buffer-02601", 43}, { {"buffer must have been created with VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT", 76}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBufferDeviceAddressInfo-buffer-02601", 43}, { {"buffer must have been created with the VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT usage flag set", 95}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferDeviceAddressInfo-buffer-parameter", 47}, { {"buffer must be a valid VkBuffer handle", 38}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferDeviceAddressInfo-pNext-pNext", 42}, { {"pNext must be NULL", 18}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferDeviceAddressInfo-sType-sType", 42}, { {"sType must be VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO", 58}, { "chapters/resources.html", 23} } }, @@ -828,10 +843,11 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkBufferMemoryRequirementsInfo2-pNext-pNext", 48}, { {"pNext must be NULL", 18}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferMemoryRequirementsInfo2-sType-sType", 48}, { {"sType must be VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2", 65}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferOpaqueCaptureAddressCreateInfo-sType-sType", 55}, { {"sType must be VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO", 73}, { "chapters/resources.html", 23} } }, - { {"VUID-VkBufferViewCreateInfo-buffer-00932", 40}, { {"buffer must have been created with a usage value containing at least one of VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT", 160}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBufferViewCreateInfo-None-12278", 38}, { {"If the ycbcr2plane444Formats feature is not enabled, format must not be VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, or VK_FORMAT_G16_B16R16_2PLANE_444_UNORM", 254}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBufferViewCreateInfo-buffer-00932", 40}, { {"buffer must have been created with at least one of the VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT usage flags set", 155}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-buffer-00935", 40}, { {"If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 107}, { "chapters/resources.html", 23} } }, - { {"VUID-VkBufferViewCreateInfo-buffer-02750", 40}, { {"If the texelBufferAlignment feature is enabled and if buffer was created with usage containing VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, offset must be a multiple of the lesser of VkPhysicalDeviceTexelBufferAlignmentProperties::storageTexelBufferOffsetAlignmentBytes or, if VkPhysicalDeviceTexelBufferAlignmentProperties::storageTexelBufferOffsetSingleTexelAlignment is VK_TRUE, the size of a texel of the requested format. If the size of a texel is a multiple of three bytes, then the size of a single component of format is used instead", 538}, { "chapters/resources.html", 23} } }, - { {"VUID-VkBufferViewCreateInfo-buffer-02751", 40}, { {"If the texelBufferAlignment feature is enabled and if buffer was created with usage containing VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, offset must be a multiple of the lesser of VkPhysicalDeviceTexelBufferAlignmentProperties::uniformTexelBufferOffsetAlignmentBytes or, if VkPhysicalDeviceTexelBufferAlignmentProperties::uniformTexelBufferOffsetSingleTexelAlignment is VK_TRUE, the size of a texel of the requested format. If the size of a texel is a multiple of three bytes, then the size of a single component of format is used instead", 538}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBufferViewCreateInfo-buffer-02750", 40}, { {"If buffer was created with the VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT usage flag set, offset must be a multiple of the effective alignment requirement of format for VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER as defined by minTexelBufferOffsetAlignment", 250}, { "chapters/resources.html", 23} } }, + { {"VUID-VkBufferViewCreateInfo-buffer-02751", 40}, { {"If buffer was created with the VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT usage flag set, offset must be a multiple of the effective alignment requirement of format for VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER as defined by minTexelBufferOffsetAlignment", 250}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-buffer-parameter", 44}, { {"buffer must be a valid VkBuffer handle", 38}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-flags-zerobitmask", 45}, { {"flags must be 0", 15}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-format-08778", 40}, { {"If the buffer view usage contains VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, then format features of format must contain VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT", 162}, { "chapters/resources.html", 23} } }, @@ -839,7 +855,6 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkBufferViewCreateInfo-format-parameter", 44}, { {"format must be a valid VkFormat value", 37}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-offset-00925", 40}, { {"offset must be less than the size of buffer", 43}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-offset-00931", 40}, { {"If range is not equal to VK_WHOLE_SIZE, the sum of offset and range must be less than or equal to the size of buffer", 116}, { "chapters/resources.html", 23} } }, - { {"VUID-VkBufferViewCreateInfo-offset-02749", 40}, { {"If the texelBufferAlignment feature is not enabled, offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment", 134}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-pNext-pNext", 39}, { {"pNext must be NULL", 18}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-range-00928", 39}, { {"If range is not equal to VK_WHOLE_SIZE, range must be greater than 0", 68}, { "chapters/resources.html", 23} } }, { {"VUID-VkBufferViewCreateInfo-range-00929", 39}, { {"If range is not equal to VK_WHOLE_SIZE, range must be an integer multiple of the texel block size of format", 107}, { "chapters/resources.html", 23} } }, @@ -902,16 +917,17 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkComponentMapping-g-parameter", 35}, { {"g must be a valid VkComponentSwizzle value", 42}, { "chapters/resources.html", 23} } }, { {"VUID-VkComponentMapping-r-parameter", 35}, { {"r must be a valid VkComponentSwizzle value", 42}, { "chapters/resources.html", 23} } }, { {"VUID-VkComputePipelineCreateInfo-None-09497", 43}, { {"flags must be a valid combination of VkPipelineCreateFlagBits values", 68}, { "chapters/pipelines.html", 23} } }, + { {"VUID-VkComputePipelineCreateInfo-None-11367", 43}, { {"layout must not be VK_NULL_HANDLE", 33}, { "chapters/pipelines.html", 23} } }, { {"VUID-VkComputePipelineCreateInfo-basePipelineHandle-05024", 57}, { {"basePipelineHandle must be VK_NULL_HANDLE", 41}, { "chapters/pipelines.html", 23} } }, { {"VUID-VkComputePipelineCreateInfo-basePipelineIndex-05025", 56}, { {"basePipelineIndex must be zero", 30}, { "chapters/pipelines.html", 23} } }, { {"VUID-VkComputePipelineCreateInfo-commonparent", 45}, { {"Both of basePipelineHandle, and layout that are valid handles of non-ignored parameters must have been created, allocated, or retrieved from the same VkDevice", 158}, { "chapters/pipelines.html", 23} } }, - { {"VUID-VkComputePipelineCreateInfo-layout-01687", 45}, { {"The number of resources in layout accessible to the compute shader stage must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources", 147}, { "chapters/pipelines.html", 23} } }, - { {"VUID-VkComputePipelineCreateInfo-layout-07987", 45}, { {"If a push constant block is declared in a shader, a push constant range in layout must match the shader stage", 109}, { "chapters/pipelines.html", 23} } }, - { {"VUID-VkComputePipelineCreateInfo-layout-07988", 45}, { {"If a resource variable is declared in a shader, the corresponding descriptor set in layout must match the shader stage", 118}, { "chapters/pipelines.html", 23} } }, - { {"VUID-VkComputePipelineCreateInfo-layout-07990", 45}, { {"If a resource variable is declared in a shader, the corresponding descriptor set in layout must match the descriptor type", 121}, { "chapters/pipelines.html", 23} } }, - { {"VUID-VkComputePipelineCreateInfo-layout-07991", 45}, { {"If a resource variable is declared in a shader as an array, the corresponding descriptor set in layout must match the descriptor count", 134}, { "chapters/pipelines.html", 23} } }, - { {"VUID-VkComputePipelineCreateInfo-layout-10069", 45}, { {"If a push constant block is declared in a shader, the block must be contained inside the push constant range in layout that matches the stage", 141}, { "chapters/pipelines.html", 23} } }, - { {"VUID-VkComputePipelineCreateInfo-layout-parameter", 49}, { {"layout must be a valid VkPipelineLayout handle", 46}, { "chapters/pipelines.html", 23} } }, + { {"VUID-VkComputePipelineCreateInfo-layout-01687", 45}, { {"If layout is not VK_NULL_HANDLE, the number of resources in layout accessible to the compute shader stage must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources", 180}, { "chapters/pipelines.html", 23} } }, + { {"VUID-VkComputePipelineCreateInfo-layout-07987", 45}, { {"If a push constant block is declared in a shader and layout is not VK_NULL_HANDLE, a push constant range in layout must match the shader stage", 142}, { "chapters/pipelines.html", 23} } }, + { {"VUID-VkComputePipelineCreateInfo-layout-07988", 45}, { {"If a resource variable is declared in a shader and layout is not VK_NULL_HANDLE, the corresponding descriptor set in layout must match the shader stage", 151}, { "chapters/pipelines.html", 23} } }, + { {"VUID-VkComputePipelineCreateInfo-layout-07990", 45}, { {"If a resource variable is declared in a shader, layout is not VK_NULL_HANDLE, the corresponding descriptor set in layout must match the descriptor type", 151}, { "chapters/pipelines.html", 23} } }, + { {"VUID-VkComputePipelineCreateInfo-layout-07991", 45}, { {"If a resource variable is declared in a shader as an array and layout is not VK_NULL_HANDLE, the corresponding descriptor binding used to create layout must have a descriptorCount that is greater than or equal to the length of the array", 236}, { "chapters/pipelines.html", 23} } }, + { {"VUID-VkComputePipelineCreateInfo-layout-10069", 45}, { {"If a push constant block is declared in a shader and layout is not VK_NULL_HANDLE, the block must be contained inside the push constant range in layout that matches the stage", 174}, { "chapters/pipelines.html", 23} } }, + { {"VUID-VkComputePipelineCreateInfo-layout-parameter", 49}, { {"If layout is not VK_NULL_HANDLE, layout must be a valid VkPipelineLayout handle", 79}, { "chapters/pipelines.html", 23} } }, { {"VUID-VkComputePipelineCreateInfo-pNext-pNext", 44}, { {"pNext must be NULL or a pointer to a valid instance of VkPipelineOfflineCreateInfo", 82}, { "chapters/pipelines.html", 23} } }, { {"VUID-VkComputePipelineCreateInfo-sType-sType", 44}, { {"sType must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO", 60}, { "chapters/pipelines.html", 23} } }, { {"VUID-VkComputePipelineCreateInfo-sType-unique", 45}, { {"The sType value of each structure in the pNext chain must be unique", 67}, { "chapters/pipelines.html", 23} } }, @@ -919,7 +935,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkComputePipelineCreateInfo-stage-00702", 44}, { {"The shader code for the entry point identified by stage and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter", 195}, { "chapters/pipelines.html", 23} } }, { {"VUID-VkComputePipelineCreateInfo-stage-parameter", 48}, { {"stage must be a valid VkPipelineShaderStageCreateInfo structure", 63}, { "chapters/pipelines.html", 23} } }, { {"VUID-VkCopyBufferInfo2-commonparent", 35}, { {"Both of dstBuffer, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice", 103}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyBufferInfo2-dstBuffer-00120", 38}, { {"dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag", 81}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyBufferInfo2-dstBuffer-00120", 38}, { {"dstBuffer must have been created with the VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag set", 89}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferInfo2-dstBuffer-00121", 38}, { {"If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 110}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferInfo2-dstBuffer-parameter", 42}, { {"dstBuffer must be a valid VkBuffer handle", 41}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferInfo2-dstOffset-00114", 38}, { {"The dstOffset member of each element of pRegions must be less than the size of dstBuffer", 88}, { "chapters/copies.html", 20} } }, @@ -930,7 +946,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkCopyBufferInfo2-sType-sType", 34}, { {"sType must be VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2", 50}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferInfo2-size-00115", 33}, { {"The size member of each element of pRegions must be less than or equal to the size of srcBuffer minus srcOffset", 111}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferInfo2-size-00116", 33}, { {"The size member of each element of pRegions must be less than or equal to the size of dstBuffer minus dstOffset", 111}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyBufferInfo2-srcBuffer-00118", 38}, { {"srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag", 81}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyBufferInfo2-srcBuffer-00118", 38}, { {"srcBuffer must have been created with the VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag set", 89}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferInfo2-srcBuffer-00119", 38}, { {"If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 110}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferInfo2-srcBuffer-parameter", 42}, { {"srcBuffer must be a valid VkBuffer handle", 41}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferInfo2-srcOffset-00113", 38}, { {"The srcOffset member of each element of pRegions must be less than the size of srcBuffer", 88}, { "chapters/copies.html", 20} } }, @@ -938,7 +954,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkCopyBufferToImageInfo2-bufferRowLength-09106", 51}, { {"For each element of pRegions, bufferRowLength must be a multiple of the texel block extent width of the VkFormat of dstImage", 124}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-bufferRowLength-09108", 51}, { {"For each element of pRegions, bufferRowLength divided by the texel block extent width and then multiplied by the texel block size of dstImage must be less than or equal to 2^31-1", 178}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-commonparent", 42}, { {"Both of dstImage, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice", 102}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyBufferToImageInfo2-dstImage-00177", 44}, { {"dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag", 79}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyBufferToImageInfo2-dstImage-00177", 44}, { {"dstImage must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 87}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-dstImage-00207", 44}, { {"For each element of pRegions, if the sum of imageOffset.x and extent.width does not equal the width of the subresource specified by imageSubresource, extent.width must be a multiple of the texel block extent width of the VkFormat of dstImage", 241}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-dstImage-00208", 44}, { {"For each element of pRegions, if the sum of imageOffset.y and extent.height does not equal the height of the subresource specified by imageSubresource, extent.height must be a multiple of the texel block extent height of the VkFormat of dstImage", 245}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-dstImage-00209", 44}, { {"For each element of pRegions, if the sum of imageOffset.z and extent.depth does not equal the depth of the subresource specified by srcSubresource, extent.depth must be a multiple of the texel block extent depth of the VkFormat of dstImage", 239}, { "chapters/copies.html", 20} } }, @@ -946,7 +962,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkCopyBufferToImageInfo2-dstImage-07274", 44}, { {"For each element of pRegions, imageOffset.x must be a multiple of the texel block extent width of the VkFormat of dstImage", 122}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-dstImage-07275", 44}, { {"For each element of pRegions, imageOffset.y must be a multiple of the texel block extent height of the VkFormat of dstImage", 123}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-dstImage-07276", 44}, { {"For each element of pRegions, imageOffset.z must be a multiple of the texel block extent depth of the VkFormat of dstImage", 122}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyBufferToImageInfo2-dstImage-07966", 44}, { {"If dstImage is non-sparse then the image or the specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 148}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyBufferToImageInfo2-dstImage-07966", 44}, { {"If dstImage is non-sparse then the image or each specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 149}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-dstImage-07973", 44}, { {"dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT", 64}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-dstImage-07975", 44}, { {"If dstImage does not have either a depth/stencil format or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the texel block size", 172}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-dstImage-07976", 44}, { {"If dstImage has a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the element size of the compatible format for the format and the aspectMask of the imageSubresource as defined in Compatible Formats of Planes of Multi-Planar Formats", 275}, { "chapters/copies.html", 20} } }, @@ -973,7 +989,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkCopyBufferToImageInfo2-pRegions-parameter", 48}, { {"pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy2 structures", 95}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-regionCount-arraylength", 53}, { {"regionCount must be greater than 0", 34}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-sType-sType", 41}, { {"sType must be VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2", 59}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyBufferToImageInfo2-srcBuffer-00174", 45}, { {"srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag", 81}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyBufferToImageInfo2-srcBuffer-00174", 45}, { {"srcBuffer must have been created with the VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag set", 89}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-srcBuffer-00176", 45}, { {"If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 110}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyBufferToImageInfo2-srcBuffer-parameter", 49}, { {"srcBuffer must be a valid VkBuffer handle", 41}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyDescriptorSet-commonparent", 37}, { {"Both of dstSet, and srcSet must have been created, allocated, or retrieved from the same VkDevice", 97}, { "chapters/descriptorsets.html", 28} } }, @@ -993,10 +1009,10 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkCopyDescriptorSet-srcSet-04887", 37}, { {"If the descriptor pool from which srcSet was allocated was created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set, then the descriptor pool from which dstSet was allocated must have been created without the VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT flag set", 285}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkCopyDescriptorSet-srcSet-parameter", 41}, { {"srcSet must be a valid VkDescriptorSet handle", 45}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkCopyImageInfo2-None-01549", 32}, { {"In a copy to or from a plane of a multi-planar image, the VkFormat of the image and plane must be compatible according to the description of compatible planes for the plane being copied", 185}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyImageInfo2-aspect-06662", 34}, { {"If the aspect member of any element of pRegions includes any flag other than VK_IMAGE_ASPECT_STENCIL_BIT or srcImage was not created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT must have been included in the VkImageCreateInfo::usage used to create srcImage", 273}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyImageInfo2-aspect-06663", 34}, { {"If the aspect member of any element of pRegions includes any flag other than VK_IMAGE_ASPECT_STENCIL_BIT or dstImage was not created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_DST_BIT must have been included in the VkImageCreateInfo::usage used to create dstImage", 273}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyImageInfo2-aspect-06664", 34}, { {"If the aspect member of any element of pRegions includes VK_IMAGE_ASPECT_STENCIL_BIT, and srcImage was created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT must have been included in the VkImageStencilUsageCreateInfo::stencilUsage used to create srcImage", 270}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyImageInfo2-aspect-06665", 34}, { {"If the aspect member of any element of pRegions includes VK_IMAGE_ASPECT_STENCIL_BIT, and dstImage was created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_DST_BIT must have been included in the VkImageStencilUsageCreateInfo::stencilUsage used to create dstImage", 270}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyImageInfo2-aspect-06662", 34}, { {"If the aspect member of any element of pRegions includes any flag other than VK_IMAGE_ASPECT_STENCIL_BIT or srcImage was not created with separate stencil usage, srcImage must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 249}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyImageInfo2-aspect-06663", 34}, { {"If the aspect member of any element of pRegions includes any flag other than VK_IMAGE_ASPECT_STENCIL_BIT or dstImage was not created with separate stencil usage, dstImage must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 249}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyImageInfo2-aspect-06664", 34}, { {"If the aspect member of any element of pRegions includes VK_IMAGE_ASPECT_STENCIL_BIT, and srcImage was created with separate stencil usage, srcImage must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 227}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyImageInfo2-aspect-06665", 34}, { {"If the aspect member of any element of pRegions includes VK_IMAGE_ASPECT_STENCIL_BIT, and dstImage was created with separate stencil usage, srcImage must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 227}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageInfo2-aspectMask-00142", 38}, { {"For each element of pRegions, srcSubresource.aspectMask must specify aspects present in srcImage", 96}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageInfo2-aspectMask-00143", 38}, { {"For each element of pRegions, dstSubresource.aspectMask must specify aspects present in dstImage", 96}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageInfo2-commonparent", 34}, { {"Both of dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice", 101}, { "chapters/copies.html", 20} } }, @@ -1007,7 +1023,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkCopyImageInfo2-dstImage-01792", 36}, { {"If dstImage is of type VK_IMAGE_TYPE_2D, and srcImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, extent.depth must equal dstSubresource.layerCount", 167}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageInfo2-dstImage-01996", 36}, { {"The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT", 79}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageInfo2-dstImage-04444", 36}, { {"If dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, dstSubresource.baseArrayLayer must be 0 and dstSubresource.layerCount must be 1", 155}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyImageInfo2-dstImage-07966", 36}, { {"If dstImage is non-sparse then the image or the specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 148}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyImageInfo2-dstImage-07966", 36}, { {"If dstImage is non-sparse then the image or each specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 149}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageInfo2-dstImage-08714", 36}, { {"If dstImage has a multi-planar format, then for each element of pRegions, dstSubresource.aspectMask must be a single valid multi-planar aspect mask bit", 151}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageInfo2-dstImage-parameter", 40}, { {"dstImage must be a valid VkImage handle", 39}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageInfo2-dstImageLayout-00133", 42}, { {"dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice", 149}, { "chapters/copies.html", 20} } }, @@ -1045,7 +1061,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkCopyImageInfo2-srcImage-01995", 36}, { {"The format features of srcImage must contain VK_FORMAT_FEATURE_TRANSFER_SRC_BIT", 79}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageInfo2-srcImage-04443", 36}, { {"If srcImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer must be 0 and srcSubresource.layerCount must be 1", 155}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageInfo2-srcImage-07743", 36}, { {"If srcImage and dstImage have a different VkImageType, one must be VK_IMAGE_TYPE_3D and the other must be VK_IMAGE_TYPE_2D", 122}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyImageInfo2-srcImage-07966", 36}, { {"If srcImage is non-sparse then the image or the specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 148}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyImageInfo2-srcImage-07966", 36}, { {"If srcImage is non-sparse then the image or each specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 149}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageInfo2-srcImage-08713", 36}, { {"If srcImage has a multi-planar format, then for each element of pRegions, srcSubresource.aspectMask must be a single valid multi-planar aspect mask bit", 151}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageInfo2-srcImage-08793", 36}, { {"If srcImage and dstImage have the same VkImageType, for each element of pRegions, the layerCount members of srcSubresource or dstSubresource must match", 151}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageInfo2-srcImage-09247", 36}, { {"If the VkFormat of each of srcImage and dstImage is a compressed image format, the formats must have the same texel block extent", 128}, { "chapters/copies.html", 20} } }, @@ -1066,7 +1082,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkCopyImageToBufferInfo2-bufferRowLength-09106", 51}, { {"For each element of pRegions, bufferRowLength must be a multiple of the texel block extent width of the VkFormat of srcImage", 124}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-bufferRowLength-09108", 51}, { {"For each element of pRegions, bufferRowLength divided by the texel block extent width and then multiplied by the texel block size of srcImage must be less than or equal to 2^31-1", 178}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-commonparent", 42}, { {"Both of dstBuffer, and srcImage must have been created, allocated, or retrieved from the same VkDevice", 102}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyImageToBufferInfo2-dstBuffer-00191", 45}, { {"dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag", 81}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyImageToBufferInfo2-dstBuffer-00191", 45}, { {"dstBuffer must have been created with the VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag set", 89}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-dstBuffer-00192", 45}, { {"If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 110}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-dstBuffer-parameter", 49}, { {"dstBuffer must be a valid VkBuffer handle", 41}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-imageOffset-00197", 47}, { {"For each element of pRegions not containing VkCopyCommandTransformInfoQCOM in its pNext chain, imageOffset.x and (imageExtent.width + imageOffset.x) must both be greater than or equal to 0 and less than or equal to the width of the specified imageSubresource of srcImage", 270}, { "chapters/copies.html", 20} } }, @@ -1082,7 +1098,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkCopyImageToBufferInfo2-pRegions-parameter", 48}, { {"pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy2 structures", 95}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-regionCount-arraylength", 53}, { {"regionCount must be greater than 0", 34}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-sType-sType", 41}, { {"sType must be VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2", 59}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyImageToBufferInfo2-srcImage-00186", 44}, { {"srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag", 79}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyImageToBufferInfo2-srcImage-00186", 44}, { {"srcImage must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 87}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-srcImage-00207", 44}, { {"For each element of pRegions, if the sum of imageOffset.x and extent.width does not equal the width of the subresource specified by imageSubresource, extent.width must be a multiple of the texel block extent width of the VkFormat of srcImage", 241}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-srcImage-00208", 44}, { {"For each element of pRegions, if the sum of imageOffset.y and extent.height does not equal the height of the subresource specified by imageSubresource, extent.height must be a multiple of the texel block extent height of the VkFormat of srcImage", 245}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-srcImage-00209", 44}, { {"For each element of pRegions, if the sum of imageOffset.z and extent.depth does not equal the depth of the subresource specified by srcSubresource, extent.depth must be a multiple of the texel block extent depth of the VkFormat of srcImage", 239}, { "chapters/copies.html", 20} } }, @@ -1090,7 +1106,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkCopyImageToBufferInfo2-srcImage-07274", 44}, { {"For each element of pRegions, imageOffset.x must be a multiple of the texel block extent width of the VkFormat of srcImage", 122}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-srcImage-07275", 44}, { {"For each element of pRegions, imageOffset.y must be a multiple of the texel block extent height of the VkFormat of srcImage", 123}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-srcImage-07276", 44}, { {"For each element of pRegions, imageOffset.z must be a multiple of the texel block extent depth of the VkFormat of srcImage", 122}, { "chapters/copies.html", 20} } }, - { {"VUID-VkCopyImageToBufferInfo2-srcImage-07966", 44}, { {"If srcImage is non-sparse then the image or the specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 148}, { "chapters/copies.html", 20} } }, + { {"VUID-VkCopyImageToBufferInfo2-srcImage-07966", 44}, { {"If srcImage is non-sparse then the image or each specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 149}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-srcImage-07973", 44}, { {"srcImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT", 64}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-srcImage-07975", 44}, { {"If srcImage does not have either a depth/stencil format or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the texel block size", 172}, { "chapters/copies.html", 20} } }, { {"VUID-VkCopyImageToBufferInfo2-srcImage-07976", 44}, { {"If srcImage has a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the element size of the compatible format for the format and the aspectMask of the imageSubresource as defined in Compatible Formats of Planes of Multi-Planar Formats", 275}, { "chapters/copies.html", 20} } }, @@ -1175,6 +1191,8 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkDescriptorSetLayoutBinding-descriptorCount-09465", 55}, { {"If descriptorCount is not 0, stageFlags must be VK_SHADER_STAGE_ALL or a valid combination of other VkShaderStageFlagBits values", 128}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkDescriptorSetLayoutBinding-descriptorType-00282", 54}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and descriptorCount is not 0 and pImmutableSamplers is not NULL, pImmutableSamplers must be a valid pointer to an array of descriptorCount valid VkSampler handles", 256}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkDescriptorSetLayoutBinding-descriptorType-01510", 54}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT and descriptorCount is not 0, then stageFlags must be 0 or VK_SHADER_STAGE_FRAGMENT_BIT", 144}, { "chapters/descriptorsets.html", 28} } }, + { {"VUID-VkDescriptorSetLayoutBinding-descriptorType-12200", 54}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and descriptorCount is not 0 and pImmutableSamplers is not NULL, either each element of pImmutableSamplers must be a VkSampler that enables sampler Y'CBCR conversion or none of them enable sampler Y'CBCR conversion", 278}, { "chapters/descriptorsets.html", 28} } }, + { {"VUID-VkDescriptorSetLayoutBinding-descriptorType-12215", 54}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, each element of pImmutableSamplers must not be a VkSampler object that enables sampler Y'CBCR conversion", 153}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkDescriptorSetLayoutBinding-descriptorType-parameter", 58}, { {"descriptorType must be a valid VkDescriptorType value", 53}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkDescriptorSetLayoutBinding-pImmutableSamplers-04009", 58}, { {"The sampler objects indicated by pImmutableSamplers must not have a borderColor with one of the values VK_BORDER_COLOR_FLOAT_CUSTOM_EXT or VK_BORDER_COLOR_INT_CUSTOM_EXT", 169}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkDescriptorSetLayoutBindingFlagsCreateInfo-None-03011", 59}, { {"All bindings with descriptor type VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC must not use VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT", 215}, { "chapters/descriptorsets.html", 28} } }, @@ -1225,8 +1243,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkDeviceCreateInfo-pQueueCreateInfos-06755", 47}, { {"If multiple elements of pQueueCreateInfos share the same queueFamilyIndex, the sum of their queueCount members must be less than or equal to the queueCount member of the VkQueueFamilyProperties structure, as returned by vkGetPhysicalDeviceQueueFamilyProperties in the pQueueFamilyProperties[queueFamilyIndex]", 308}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter", 51}, { {"If queueCreateInfoCount is not 0, pQueueCreateInfos must be a valid pointer to an array of queueCreateInfoCount valid VkDeviceQueueCreateInfo structures", 152}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-parameter", 57}, { {"If enabledExtensionCount is not 0, ppEnabledExtensionNames must be a valid pointer to an array of enabledExtensionCount null-terminated UTF-8 strings", 149}, { "chapters/devsandqueues.html", 27} } }, - { {"VUID-VkDeviceCreateInfo-ppEnabledLayerNames-parameter", 53}, { {"If enabledLayerCount is not 0, ppEnabledLayerNames must be a valid pointer to an array of enabledLayerCount null-terminated UTF-8 strings", 137}, { "chapters/devsandqueues.html", 27} } }, - { {"VUID-VkDeviceCreateInfo-queueFamilyIndex-02802", 46}, { {"The queueFamilyIndex member of each element of pQueueCreateInfos must be unique within pQueueCreateInfos , except that two members can share the same queueFamilyIndex if one describes protected-capable queues and one describes queues that are not protected-capable", 264}, { "chapters/devsandqueues.html", 27} } }, + { {"VUID-VkDeviceCreateInfo-queueFamilyIndex-02802", 46}, { {"The combination of the values in the queueFamilyIndex and flags members of each element of pQueueCreateInfos must be unique within pQueueCreateInfos", 148}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-VkDeviceCreateInfo-robustBufferAccess-10247", 48}, { {"If the robustBufferAccess feature is enabled, and robustBufferAccessUpdateAfterBind is VK_FALSE, then descriptorBindingUniformBufferUpdateAfterBind, descriptorBindingStorageBufferUpdateAfterBind, descriptorBindingUniformTexelBufferUpdateAfterBind, and descriptorBindingStorageTexelBufferUpdateAfterBind must not be enabled", 322}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-VkDeviceCreateInfo-sType-sType", 35}, { {"sType must be VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO", 50}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-VkDeviceCreateInfo-sType-unique", 36}, { {"The sType value of each structure in the pNext chain must be unique, with the exception of structures of type VkApplicationParametersEXT, VkDeviceObjectReservationCreateInfo, VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV, or VkPerformanceQueryReservationInfoKHR", 267}, { "chapters/devsandqueues.html", 27} } }, @@ -1459,12 +1476,12 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkFramebufferCreateInfo-flags-04538", 40}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, and renderPass was not specified with non-zero view masks, each element of pAttachments that is used as a fragment shading rate attachment by renderPass must have a layerCount that is either 1, or greater than layers", 279}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-flags-04539", 40}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, an element of pAttachments that is used as a fragment shading rate attachment must have a width at least as large as ceil(width / texelWidth), where texelWidth is the largest value of shadingRateAttachmentTexelSize.width in a VkFragmentShadingRateAttachmentInfoKHR which references that attachment", 360}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-flags-04540", 40}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, an element of pAttachments that is used as a fragment shading rate attachment must have a height at least as large as ceil(height / texelHeight), where texelHeight is the largest value of shadingRateAttachmentTexelSize.height in a VkFragmentShadingRateAttachmentInfoKHR which references that attachment", 365}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkFramebufferCreateInfo-flags-04541", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the width member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as an input, color, resolve or depth/stencil attachment in renderPass must be greater than or equal to width", 313}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkFramebufferCreateInfo-flags-04542", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the height member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as an input, color, resolve or depth/stencil attachment in renderPass must be greater than or equal to height", 315}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkFramebufferCreateInfo-flags-04541", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the width member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as an input, color, resolve, or depth/stencil attachment in renderPass must be greater than or equal to width", 314}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkFramebufferCreateInfo-flags-04542", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the height member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as an input, color, resolve, or depth/stencil attachment in renderPass must be greater than or equal to height", 316}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-flags-04543", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the width member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as a fragment shading rate attachment must be greater than or equal to ceil(width / texelWidth), where texelWidth is the largest value of shadingRateAttachmentTexelSize.width in a VkFragmentShadingRateAttachmentInfoKHR which references that attachment", 456}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-flags-04544", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the height member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as a fragment shading rate attachment must be greater than or equal to ceil(height / texelHeight), where texelHeight is the largest value of shadingRateAttachmentTexelSize.height in a VkFragmentShadingRateAttachmentInfoKHR which references that attachment", 461}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-flags-04545", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the layerCount member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as a fragment shading rate attachment must be either 1, or greater than or equal to layers", 300}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkFramebufferCreateInfo-flags-04548", 40}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a fragment shading rate attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR", 264}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkFramebufferCreateInfo-flags-04548", 40}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a fragment shading rate attachment by renderPass must have been created with the VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR usage flag set", 259}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-flags-04549", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the usage member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain that refers to an attachment used as a fragment shading rate attachment by renderPass must include VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR", 355}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-flags-04587", 40}, { {"If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT and renderPass was specified with non-zero view masks, the layerCount member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure in the pNext chain that is used as a fragment shading rate attachment must be either 1, or greater than the index of the most significant bit set in any of those view masks", 404}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-flags-parameter", 44}, { {"flags must be a valid combination of VkFramebufferCreateFlagBits values", 71}, { "chapters/renderpass.html", 24} } }, @@ -1472,15 +1489,15 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkFramebufferCreateInfo-height-00888", 41}, { {"height must be less than or equal to maxFramebufferHeight", 57}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-layers-00889", 41}, { {"layers must be greater than 0", 29}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-layers-00890", 41}, { {"layers must be less than or equal to maxFramebufferLayers", 57}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkFramebufferCreateInfo-pAttachments-00877", 47}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a color attachment or resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT", 250}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkFramebufferCreateInfo-pAttachments-00879", 47}, { {"If renderpass is not VK_NULL_HANDLE, flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as an input attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", 263}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkFramebufferCreateInfo-pAttachments-00877", 47}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a color attachment or resolve attachment by renderPass must have been created with the VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT usage flag set", 245}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkFramebufferCreateInfo-pAttachments-00879", 47}, { {"If renderpass is not VK_NULL_HANDLE, flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as an input attachment by renderPass must have been created with the VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage flag set", 258}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-pAttachments-00880", 47}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with a VkFormat value that matches the VkFormat specified by the corresponding VkAttachmentDescription in renderPass", 231}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-pAttachments-00881", 47}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with a samples value that matches the samples value specified by the corresponding VkAttachmentDescription in renderPass", 235}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-pAttachments-00883", 47}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must only specify a single mip level", 128}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-pAttachments-00884", 47}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments must have been created with the identity swizzle", 140}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-pAttachments-00891", 47}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is a 2D or 2D array image view taken from a 3D image must not be a depth/stencil format", 184}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkFramebufferCreateInfo-pAttachments-02633", 47}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a depth/stencil attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 244}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkFramebufferCreateInfo-pAttachments-02634", 47}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a depth/stencil resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 252}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkFramebufferCreateInfo-pAttachments-02633", 47}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a depth/stencil attachment by renderPass must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 239}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkFramebufferCreateInfo-pAttachments-02634", 47}, { {"If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, each element of pAttachments that is used as a depth/stencil resolve attachment by renderPass must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 247}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-pNext-pNext", 40}, { {"pNext must be NULL or a pointer to a valid instance of VkFramebufferAttachmentsCreateInfo", 89}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-renderPass-02531", 45}, { {"If renderPass was specified with non-zero view masks, layers must be 1", 70}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkFramebufferCreateInfo-renderPass-03198", 45}, { {"If multiview is enabled for renderPass and flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, the layerCount member of any element of the pAttachmentImageInfos member of a VkFramebufferAttachmentsCreateInfo structure included in the pNext chain used as an input, color, resolve, or depth/stencil attachment in renderPass must be greater than the maximum bit index set in the view mask in the subpasses in which it is used in renderPass", 436}, { "chapters/renderpass.html", 24} } }, @@ -1510,11 +1527,11 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkGraphicsPipelineCreateInfo-fragmentShadingRateNonTrivialCombinerOps-04506", 80}, { {"If the pipeline requires pre-rasterization shader state or fragment shader state, the fragmentShadingRateNonTrivialCombinerOps limit is not supported, and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, elements of VkPipelineFragmentShadingRateStateCreateInfoKHR::combinerOps must be VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR or VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR", 426}, { "chapters/pipelines.html", 23} } }, { {"VUID-VkGraphicsPipelineCreateInfo-layout-01688", 46}, { {"The number of resources in layout accessible to each shader stage that is used by the pipeline must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources", 169}, { "chapters/pipelines.html", 23} } }, { {"VUID-VkGraphicsPipelineCreateInfo-layout-06602", 46}, { {"If the pipeline requires fragment shader state or pre-rasterization shader state, layout must be a valid VkPipelineLayout handle", 128}, { "chapters/pipelines.html", 23} } }, - { {"VUID-VkGraphicsPipelineCreateInfo-layout-07987", 46}, { {"If a push constant block is declared in a shader, a push constant range in layout must match the shader stage", 109}, { "chapters/pipelines.html", 23} } }, - { {"VUID-VkGraphicsPipelineCreateInfo-layout-07988", 46}, { {"If a resource variable is declared in a shader, the corresponding descriptor set in layout must match the shader stage", 118}, { "chapters/pipelines.html", 23} } }, - { {"VUID-VkGraphicsPipelineCreateInfo-layout-07990", 46}, { {"If a resource variable is declared in a shader, the corresponding descriptor set in layout must match the descriptor type", 121}, { "chapters/pipelines.html", 23} } }, - { {"VUID-VkGraphicsPipelineCreateInfo-layout-07991", 46}, { {"If a resource variable is declared in a shader as an array, the corresponding descriptor set in layout must match the descriptor count", 134}, { "chapters/pipelines.html", 23} } }, - { {"VUID-VkGraphicsPipelineCreateInfo-layout-10069", 46}, { {"If a push constant block is declared in a shader, the block must be contained inside the push constant range in layout that matches the stage", 141}, { "chapters/pipelines.html", 23} } }, + { {"VUID-VkGraphicsPipelineCreateInfo-layout-07987", 46}, { {"If a push constant block is declared in a shader and layout is not VK_NULL_HANDLE, a push constant range in layout must match the shader stage", 142}, { "chapters/pipelines.html", 23} } }, + { {"VUID-VkGraphicsPipelineCreateInfo-layout-07988", 46}, { {"If a resource variable is declared in a shader and layout is not VK_NULL_HANDLE, the corresponding descriptor set in layout must match the shader stage", 151}, { "chapters/pipelines.html", 23} } }, + { {"VUID-VkGraphicsPipelineCreateInfo-layout-07990", 46}, { {"If a resource variable is declared in a shader, layout is not VK_NULL_HANDLE, the corresponding descriptor set in layout must match the descriptor type", 151}, { "chapters/pipelines.html", 23} } }, + { {"VUID-VkGraphicsPipelineCreateInfo-layout-07991", 46}, { {"If a resource variable is declared in a shader as an array and layout is not VK_NULL_HANDLE, the corresponding descriptor binding used to create layout must have a descriptorCount that is greater than or equal to the length of the array", 236}, { "chapters/pipelines.html", 23} } }, + { {"VUID-VkGraphicsPipelineCreateInfo-layout-10069", 46}, { {"If a push constant block is declared in a shader and layout is not VK_NULL_HANDLE, the block must be contained inside the push constant range in layout that matches the stage", 174}, { "chapters/pipelines.html", 23} } }, { {"VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766", 61}, { {"If the pipeline requires pre-rasterization shader state and at least one of fragment output interface state or fragment shader state, and pMultisampleState is not NULL, the lineRasterizationMode member of a VkPipelineRasterizationLineStateCreateInfo structure included in the pNext chain of pRasterizationState is VK_LINE_RASTERIZATION_MODE_BRESENHAM or VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH, then the alphaToCoverageEnable, alphaToOneEnable, and sampleShadingEnable members of pMultisampleState must all be VK_FALSE", 524}, { "chapters/pipelines.html", 23} } }, { {"VUID-VkGraphicsPipelineCreateInfo-pDepthStencilState-09029", 58}, { {"If pDepthStencilState is not NULL it must be a valid pointer to a valid VkPipelineDepthStencilStateCreateInfo structure", 119}, { "chapters/pipelines.html", 23} } }, { {"VUID-VkGraphicsPipelineCreateInfo-pDynamicState-04494", 53}, { {"If the pipeline requires pre-rasterization shader state or fragment shader state and VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR is not included in pDynamicState->pDynamicStates, VkPipelineFragmentShadingRateStateCreateInfoKHR::fragmentSize.width must be greater than or equal to 1", 280}, { "chapters/pipelines.html", 23} } }, @@ -1632,6 +1649,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkImageCopy2-sType-sType", 29}, { {"sType must be VK_STRUCTURE_TYPE_IMAGE_COPY_2", 44}, { "chapters/copies.html", 20} } }, { {"VUID-VkImageCopy2-srcSubresource-parameter", 42}, { {"srcSubresource must be a valid VkImageSubresourceLayers structure", 65}, { "chapters/copies.html", 20} } }, { {"VUID-VkImageCreateInfo-Format-02536", 35}, { {"If Format is a depth-stencil format and the pNext chain includes a VkImageStencilUsageCreateInfo structure with its stencilUsage member including VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, extent.width must be less than or equal to VkPhysicalDeviceLimits::maxFramebufferWidth", 269}, { "chapters/resources.html", 23} } }, + { {"VUID-VkImageCreateInfo-None-12279", 33}, { {"If the ycbcr2plane444Formats feature is not enabled, format must not be VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, or VK_FORMAT_G16_B16R16_2PLANE_444_UNORM", 254}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageCreateInfo-arrayLayers-00948", 40}, { {"arrayLayers must be greater than 0", 34}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageCreateInfo-arrayLayers-02256", 40}, { {"arrayLayers must be less than or equal to imageCreateMaxArrayLayers (as defined in Image Creation Limits)", 105}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageCreateInfo-extent-00944", 35}, { {"extent.width must be greater than 0", 35}, { "chapters/resources.html", 23} } }, @@ -1736,7 +1754,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkImageMemoryBarrier-aspectMask-08703", 42}, { {"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", 209}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-dstQueueFamilyIndex-09122", 51}, { {"If the VK_EXT_queue_family_foreign extension is not enabled dstQueueFamilyIndex must not be VK_QUEUE_FAMILY_FOREIGN_EXT", 119}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-image-01672", 37}, { {"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 bit or VK_IMAGE_ASPECT_COLOR_BIT", 192}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-image-01932", 37}, { {"If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 106}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-image-01932", 37}, { {"If image is non-sparse then the image or each specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 146}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-image-03319", 37}, { {"If image has a depth/stencil format with both depth and stencil and the separateDepthStencilLayouts feature is enabled, then the aspectMask member of subresourceRange must include either or both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT", 252}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-image-03320", 37}, { {"If image has a depth/stencil format with both depth and stencil and the separateDepthStencilLayouts feature is not enabled, then the aspectMask member of subresourceRange must include both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT", 246}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-image-09117", 37}, { {"If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, srcQueueFamilyIndex must be VK_QUEUE_FAMILY_EXTERNAL, VK_QUEUE_FAMILY_FOREIGN_EXT, or a valid queue family", 240}, { "chapters/synchronization.html", 29} } }, @@ -1746,28 +1764,28 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkImageMemoryBarrier-image-10749", 37}, { {"If image has a depth-only format then the aspectMask member of subresourceRange must be VK_IMAGE_ASPECT_DEPTH_BIT", 113}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-image-10750", 37}, { {"If image has a stencil-only format then the aspectMask member of subresourceRange must be VK_IMAGE_ASPECT_STENCIL_BIT", 117}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-image-parameter", 41}, { {"image must be a valid VkImage handle", 36}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-newLayout-01198", 41}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, newLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED", 231}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-newLayout-01198", 41}, { {"If layouts are not ignored, newLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED", 109}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-newLayout-parameter", 45}, { {"newLayout must be a valid VkImageLayout value", 45}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-oldLayout-01197", 41}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, oldLayout must be VK_IMAGE_LAYOUT_UNDEFINED or the current layout of the image subresources affected by the barrier", 265}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-oldLayout-01208", 41}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT", 295}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-oldLayout-01209", 41}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 311}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-oldLayout-01210", 41}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 310}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-oldLayout-01211", 41}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", 325}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-oldLayout-01212", 41}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT", 287}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-oldLayout-01213", 41}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT", 287}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-oldLayout-01658", 41}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 321}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-oldLayout-01659", 41}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 321}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-oldLayout-02088", 41}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR then image must have been created with VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR set", 339}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-oldLayout-01197", 41}, { {"If layouts are not ignored, oldLayout must be VK_IMAGE_LAYOUT_UNDEFINED or the current layout of the image subresources affected by the barrier", 143}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-oldLayout-01208", 41}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT usage flag set", 188}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-oldLayout-01209", 41}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 204}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-oldLayout-01210", 41}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 203}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-oldLayout-01211", 41}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage flag set", 218}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-oldLayout-01212", 41}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 180}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-oldLayout-01213", 41}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 180}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-oldLayout-01658", 41}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 214}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-oldLayout-01659", 41}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 214}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-oldLayout-02088", 41}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR then image must have been created with the VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR usage flag set", 228}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-oldLayout-parameter", 45}, { {"oldLayout must be a valid VkImageLayout value", 45}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-pNext-pNext", 37}, { {"pNext must be NULL or a pointer to a valid instance of VkSampleLocationsInfoEXT", 79}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-sType-sType", 37}, { {"sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER", 52}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-sType-unique", 38}, { {"The sType value of each structure in the pNext chain must be unique", 67}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-03938", 51}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT or VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 332}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-03939", 51}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, image must have been created with at least one of VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", 376}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-04065", 51}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL then image must have been created with at least one of VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", 386}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-04066", 51}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set", 307}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-04067", 51}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with at least one of VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", 388}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-04068", 51}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set", 309}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-03938", 51}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, image must have been created with the VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT or VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 225}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-03939", 51}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, image must have been created with at least one of the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage flags set", 270}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-04065", 51}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL then image must have been created with at least one of the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage flags set", 280}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-04066", 51}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 196}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-04067", 51}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with at least one of the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage flags set", 282}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-04068", 51}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 198}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-srcQueueFamilyIndex-09121", 51}, { {"If the VK_EXT_queue_family_foreign extension is not enabled srcQueueFamilyIndex must not be VK_QUEUE_FAMILY_FOREIGN_EXT", 119}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-subresourceRange-01486", 48}, { {"subresourceRange.baseMipLevel must be less than the mipLevels specified in VkImageCreateInfo when image was created", 115}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier-subresourceRange-01488", 48}, { {"subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created", 119}, { "chapters/synchronization.html", 29} } }, @@ -1805,7 +1823,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkImageMemoryBarrier2-dstStageMask-07317", 45}, { {"If the attachmentFragmentShadingRate feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR", 151}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-dstStageMask-parameter", 49}, { {"dstStageMask must be a valid combination of VkPipelineStageFlagBits2 values", 75}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-image-01672", 38}, { {"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 bit or VK_IMAGE_ASPECT_COLOR_BIT", 192}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-image-01932", 38}, { {"If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 106}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-image-01932", 38}, { {"If image is non-sparse then the image or each specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 146}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-image-03319", 38}, { {"If image has a depth/stencil format with both depth and stencil and the separateDepthStencilLayouts feature is enabled, then the aspectMask member of subresourceRange must include either or both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT", 252}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-image-03320", 38}, { {"If image has a depth/stencil format with both depth and stencil and the separateDepthStencilLayouts feature is not enabled, then the aspectMask member of subresourceRange must include both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT", 246}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-image-09117", 38}, { {"If image was created with a sharing mode of VK_SHARING_MODE_EXCLUSIVE, and srcQueueFamilyIndex and dstQueueFamilyIndex are not equal, srcQueueFamilyIndex must be VK_QUEUE_FAMILY_EXTERNAL, VK_QUEUE_FAMILY_FOREIGN_EXT, or a valid queue family", 240}, { "chapters/synchronization.html", 29} } }, @@ -1815,18 +1833,18 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkImageMemoryBarrier2-image-10749", 38}, { {"If image has a depth-only format then the aspectMask member of subresourceRange must be VK_IMAGE_ASPECT_DEPTH_BIT", 113}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-image-10750", 38}, { {"If image has a stencil-only format then the aspectMask member of subresourceRange must be VK_IMAGE_ASPECT_STENCIL_BIT", 117}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-image-parameter", 42}, { {"image must be a valid VkImage handle", 36}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-newLayout-01198", 42}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, newLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED", 231}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-newLayout-01198", 42}, { {"If layouts are not ignored, newLayout must not be VK_IMAGE_LAYOUT_UNDEFINED or VK_IMAGE_LAYOUT_PREINITIALIZED", 109}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-newLayout-parameter", 46}, { {"newLayout must be a valid VkImageLayout value", 45}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-oldLayout-01197", 42}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, oldLayout must be VK_IMAGE_LAYOUT_UNDEFINED or the current layout of the image subresources affected by the barrier", 265}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-oldLayout-01208", 42}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT", 295}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-oldLayout-01209", 42}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 311}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-oldLayout-01210", 42}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 310}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-oldLayout-01211", 42}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", 325}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-oldLayout-01212", 42}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT", 287}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-oldLayout-01213", 42}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT", 287}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-oldLayout-01658", 42}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 321}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-oldLayout-01659", 42}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 321}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-oldLayout-02088", 42}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR then image must have been created with VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR set", 339}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-oldLayout-01197", 42}, { {"If layouts are not ignored, oldLayout must be VK_IMAGE_LAYOUT_UNDEFINED or the current layout of the image subresources affected by the barrier", 143}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-oldLayout-01208", 42}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT usage flag set", 188}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-oldLayout-01209", 42}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 204}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-oldLayout-01210", 42}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 203}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-oldLayout-01211", 42}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage flag set", 218}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-oldLayout-01212", 42}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 180}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-oldLayout-01213", 42}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 180}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-oldLayout-01658", 42}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 214}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-oldLayout-01659", 42}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 214}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-oldLayout-02088", 42}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR then image must have been created with the VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR usage flag set", 228}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-oldLayout-parameter", 46}, { {"oldLayout must be a valid VkImageLayout value", 45}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-pNext-pNext", 38}, { {"pNext must be NULL or a pointer to a valid instance of VkSampleLocationsInfoEXT", 79}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-sType-sType", 38}, { {"sType must be VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2", 54}, { "chapters/synchronization.html", 29} } }, @@ -1851,12 +1869,12 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkImageMemoryBarrier2-srcAccessMask-03926", 46}, { {"If srcAccessMask includes VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT, srcStageMask must include VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, or VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT", 232}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-srcAccessMask-07454", 46}, { {"If srcAccessMask includes VK_ACCESS_2_SHADER_READ_BIT, srcStageMask must include VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT, VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT, or one of the VK_PIPELINE_STAGE_*_SHADER_BIT stages", 208}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-srcAccessMask-parameter", 50}, { {"srcAccessMask must be a valid combination of VkAccessFlagBits2 values", 69}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-03938", 52}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, image must have been created with VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT or VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 332}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-03939", 52}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, image must have been created with at least one of VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", 376}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-04065", 52}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL then image must have been created with at least one of VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", 386}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-04066", 52}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set", 307}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-04067", 52}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with at least one of VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", 388}, { "chapters/synchronization.html", 29} } }, - { {"VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-04068", 52}, { {"If srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, and oldLayout or newLayout is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT set", 309}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-03938", 52}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, image must have been created with the VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT or VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 225}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-03939", 52}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, image must have been created with at least one of the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage flags set", 270}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-04065", 52}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL then image must have been created with at least one of the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage flags set", 280}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-04066", 52}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 196}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-04067", 52}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then image must have been created with at least one of the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_USAGE_SAMPLED_BIT, or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage flags set", 282}, { "chapters/synchronization.html", 29} } }, + { {"VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-04068", 52}, { {"If layouts are not ignored, oldLayout or newLayout is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL then image must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 198}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-srcQueueFamilyIndex-09121", 52}, { {"If the VK_EXT_queue_family_foreign extension is not enabled srcQueueFamilyIndex must not be VK_QUEUE_FAMILY_FOREIGN_EXT", 119}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-srcStageMask-03854", 45}, { {"If either srcStageMask or dstStageMask includes VK_PIPELINE_STAGE_2_HOST_BIT, srcQueueFamilyIndex and dstQueueFamilyIndex must be equal", 135}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImageMemoryBarrier2-srcStageMask-03855", 45}, { {"If srcStageMask includes VK_PIPELINE_STAGE_2_HOST_BIT, and srcQueueFamilyIndex and dstQueueFamilyIndex define a queue family ownership transfer or oldLayout and newLayout define an image layout transition, oldLayout must be one of VK_IMAGE_LAYOUT_PREINITIALIZED, VK_IMAGE_LAYOUT_UNDEFINED, or VK_IMAGE_LAYOUT_GENERAL", 316}, { "chapters/synchronization.html", 29} } }, @@ -1924,6 +1942,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkImageViewASTCDecodeModeEXT-format-04084", 46}, { {"format of the image view must be one of the ASTC Compressed Image Formats", 73}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewASTCDecodeModeEXT-sType-sType", 45}, { {"sType must be VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT", 63}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-None-02273", 37}, { {"The format features of the resultant image view must contain at least one bit", 77}, { "chapters/resources.html", 23} } }, + { {"VUID-VkImageViewCreateInfo-None-12280", 37}, { {"If the ycbcr2plane444Formats feature is not enabled, format must not be VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, or VK_FORMAT_G16_B16R16_2PLANE_444_UNORM", 254}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-components-parameter", 47}, { {"components must be a valid VkComponentMapping structure", 55}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-flags-zerobitmask", 44}, { {"flags must be 0", 15}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-format-04714", 39}, { {"If format has a _422 or _420 suffix then image must have been created with a width that is a multiple of 2", 106}, { "chapters/resources.html", 23} } }, @@ -1931,15 +1950,15 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkImageViewCreateInfo-format-06415", 39}, { {"If the image view requires a sampler Y'CBCR conversion and usage contains VK_IMAGE_USAGE_SAMPLED_BIT, then the pNext chain must include a VkSamplerYcbcrConversionInfo structure with a conversion value other than VK_NULL_HANDLE", 226}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-format-parameter", 43}, { {"format must be a valid VkFormat value", 37}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-image-01003", 38}, { {"If image was not created with VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT then viewType must not be VK_IMAGE_VIEW_TYPE_CUBE or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY", 148}, { "chapters/resources.html", 23} } }, - { {"VUID-VkImageViewCreateInfo-image-01020", 38}, { {"If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 106}, { "chapters/resources.html", 23} } }, + { {"VUID-VkImageViewCreateInfo-image-01020", 38}, { {"If image is non-sparse then the image or each specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 146}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-image-01482", 38}, { {"If image is not a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, or viewType is not VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange.baseArrayLayer must be less than the arrayLayers specified in VkImageCreateInfo when image was created", 277}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-image-01583", 38}, { {"If image was created with the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, format must be compatible with, or must be an uncompressed format that is size-compatible with, the format used to create image", 211}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-image-01586", 38}, { {"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 mask bits, 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", 395}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-image-01761", 38}, { {"If image was created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, but without the VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT flag, and if the format of the image is not a multi-planar format, format must be compatible with the format used to create image, as defined in Format Compatibility Classes", 308}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-image-01762", 38}, { {"If image was not created with the VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT flag, or if the format of the image is a multi-planar format and if subresourceRange.aspectMask is VK_IMAGE_ASPECT_COLOR_BIT, format must be identical to the format used to create image", 254}, { "chapters/resources.html", 23} } }, - { {"VUID-VkImageViewCreateInfo-image-02086", 38}, { {"If image was created with usage containing VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, viewType must be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY", 169}, { "chapters/resources.html", 23} } }, + { {"VUID-VkImageViewCreateInfo-image-02086", 38}, { {"If image was created with the VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR usage flag set, viewType must be VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY", 171}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-image-02724", 38}, { {"If image is a 3D image created with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set, and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY, subresourceRange.baseArrayLayer must be less than the depth computed from baseMipLevel and extent.depth specified in VkImageCreateInfo when image was created, according to the formula defined in Image Mip Level Sizing", 368}, { "chapters/resources.html", 23} } }, - { {"VUID-VkImageViewCreateInfo-image-04441", 38}, { {"image must have been created with a usage value containing at least one of the usages defined in the valid image usage list for image views", 139}, { "chapters/resources.html", 23} } }, + { {"VUID-VkImageViewCreateInfo-image-04441", 38}, { {"image must have been created with a usage value containing at least one of the following: VK_IMAGE_USAGE_SAMPLED_BIT VK_IMAGE_USAGE_STORAGE_BIT VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR", 355}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-image-04970", 38}, { {"If image was created with VK_IMAGE_TYPE_3D and viewType is VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY then subresourceRange.levelCount must be 1", 154}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-image-04972", 38}, { {"If image was created with a samples value not equal to VK_SAMPLE_COUNT_1_BIT then viewType must be either VK_IMAGE_VIEW_TYPE_2D or VK_IMAGE_VIEW_TYPE_2D_ARRAY", 158}, { "chapters/resources.html", 23} } }, { {"VUID-VkImageViewCreateInfo-image-06723", 38}, { {"If image was created with VK_IMAGE_TYPE_3D but without VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT set then viewType must not be VK_IMAGE_VIEW_TYPE_2D_ARRAY", 152}, { "chapters/resources.html", 23} } }, @@ -2006,7 +2025,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkImportFenceSciSyncInfoNV-sType-sType", 43}, { {"sType must be VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV", 61}, { "chapters/synchronization.html", 29} } }, { {"VUID-VkImportMemoryFdInfoKHR-fd-00668", 37}, { {"The memory from which fd was exported must have been created on the same underlying physical device as device", 109}, { "chapters/memory.html", 20} } }, { {"VUID-VkImportMemoryFdInfoKHR-fd-01520", 37}, { {"fd must obey any requirements listed for handleType in external memory handle types compatibility", 97}, { "chapters/memory.html", 20} } }, - { {"VUID-VkImportMemoryFdInfoKHR-fd-01746", 37}, { {"The memory represented by fd must have been created from a physical device and driver that is compatible with device and handleType, as described in External Memory Handle Types Compatibility", 191}, { "chapters/memory.html", 20} } }, + { {"VUID-VkImportMemoryFdInfoKHR-fd-01746", 37}, { {"The memory represented by fd must have been created from a physical device and driver that is compatible with device and handleType, as described in external memory handle types compatibility", 191}, { "chapters/memory.html", 20} } }, { {"VUID-VkImportMemoryFdInfoKHR-handleType-00669", 45}, { {"If handleType is not 0, it must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT", 129}, { "chapters/memory.html", 20} } }, { {"VUID-VkImportMemoryFdInfoKHR-handleType-00670", 45}, { {"If handleType is not 0, fd must be a valid handle of the type specified by handleType", 85}, { "chapters/memory.html", 20} } }, { {"VUID-VkImportMemoryFdInfoKHR-handleType-09862", 45}, { {"If handleType is not 0, it must be supported for import, as reported by VkExternalImageFormatProperties or VkExternalBufferProperties", 133}, { "chapters/memory.html", 20} } }, @@ -2669,10 +2688,10 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkRenderPassCreateInfo-pAttachments-01567", 46}, { {"For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL", 216}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo-pAttachments-02511", 46}, { {"For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL", 249}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo-pAttachments-parameter", 50}, { {"If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription structures", 137}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkRenderPassCreateInfo-pDependencies-00837", 47}, { {"For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be VK_PIPELINE_STAGE_ALL_COMMANDS_BIT or a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass", 304}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkRenderPassCreateInfo-pDependencies-00838", 47}, { {"For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be VK_PIPELINE_STAGE_ALL_COMMANDS_BIT or a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass", 309}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkRenderPassCreateInfo-pDependencies-06866", 47}, { {"For any element of pDependencies, if its srcSubpass is not VK_SUBPASS_EXTERNAL, it must be less than subpassCount", 113}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkRenderPassCreateInfo-pDependencies-06867", 47}, { {"For any element of pDependencies, if its dstSubpass is not VK_SUBPASS_EXTERNAL, it must be less than subpassCount", 113}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkRenderPassCreateInfo-pDependencies-00837", 47}, { {"For each element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be VK_PIPELINE_STAGE_ALL_COMMANDS_BIT or a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass", 305}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkRenderPassCreateInfo-pDependencies-00838", 47}, { {"For each element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be VK_PIPELINE_STAGE_ALL_COMMANDS_BIT or a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass", 310}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkRenderPassCreateInfo-pDependencies-06866", 47}, { {"For each element of pDependencies, if its srcSubpass is not VK_SUBPASS_EXTERNAL, it must be less than subpassCount", 114}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkRenderPassCreateInfo-pDependencies-06867", 47}, { {"For each element of pDependencies, if its dstSubpass is not VK_SUBPASS_EXTERNAL, it must be less than subpassCount", 114}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo-pDependencies-parameter", 51}, { {"If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency structures", 134}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo-pNext-01926", 39}, { {"If the pNext chain includes a VkRenderPassInputAttachmentAspectCreateInfo structure, the subpass member of each element of its pAspectReferences member must be less than subpassCount", 182}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo-pNext-01927", 39}, { {"If the pNext chain includes a VkRenderPassInputAttachmentAspectCreateInfo structure, the inputAttachmentIndex member of each element of its pAspectReferences member must be less than the value of inputAttachmentCount in the element of pSubpasses identified by its subpass member", 278}, { "chapters/renderpass.html", 24} } }, @@ -2680,7 +2699,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkRenderPassCreateInfo-pNext-01929", 39}, { {"If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, if its dependencyCount member is not zero, it must be equal to dependencyCount", 151}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo-pNext-01930", 39}, { {"If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, for each non-zero element of pViewOffsets, the srcSubpass and dstSubpass members of pDependencies at the same index must not be equal", 206}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo-pNext-01963", 39}, { {"If the pNext chain includes a VkRenderPassInputAttachmentAspectCreateInfo structure, for any element of the pInputAttachments member of any element of pSubpasses where the attachment member is not VK_ATTACHMENT_UNUSED, the aspectMask member of the corresponding element of VkRenderPassInputAttachmentAspectCreateInfo::pAspectReferences must only include aspects that are present in images of the format specified by the element of pAttachments at attachment", 457}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkRenderPassCreateInfo-pNext-02512", 39}, { {"If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, for any element of pDependencies with a dependencyFlags member that does not include VK_DEPENDENCY_VIEW_LOCAL_BIT, the corresponding element of the pViewOffsets member of that VkRenderPassMultiviewCreateInfo instance must be 0", 299}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkRenderPassCreateInfo-pNext-02512", 39}, { {"If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, for each element of pDependencies with a dependencyFlags member that does not include VK_DEPENDENCY_VIEW_LOCAL_BIT, the corresponding element of the pViewOffsets member of that VkRenderPassMultiviewCreateInfo instance must be 0", 300}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo-pNext-02513", 39}, { {"If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, elements of its pViewMasks member must either all be 0, or all not be 0", 144}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo-pNext-02514", 39}, { {"If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, and each element of its pViewMasks member is 0, the dependencyFlags member of each element of pDependencies must not include VK_DEPENDENCY_VIEW_LOCAL_BIT", 226}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo-pNext-02515", 39}, { {"If the pNext chain includes a VkRenderPassMultiviewCreateInfo structure, and each element of its pViewMasks member is 0, its correlationMaskCount member must be 0", 162}, { "chapters/renderpass.html", 24} } }, @@ -2710,9 +2729,9 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkRenderPassCreateInfo2-pAttachments-parameter", 51}, { {"If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription2 structures", 138}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo2-pCorrelatedViewMasks-03056", 55}, { {"The set of bits included in any element of pCorrelatedViewMasks must not overlap with the set of bits included in any other element of pCorrelatedViewMasks", 155}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo2-pCorrelatedViewMasks-parameter", 59}, { {"If correlatedViewMaskCount is not 0, pCorrelatedViewMasks must be a valid pointer to an array of correlatedViewMaskCount uint32_t values", 136}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkRenderPassCreateInfo2-pDependencies-03054", 48}, { {"For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be VK_PIPELINE_STAGE_ALL_COMMANDS_BIT or a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass", 304}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkRenderPassCreateInfo2-pDependencies-03055", 48}, { {"For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be VK_PIPELINE_STAGE_ALL_COMMANDS_BIT or a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass", 309}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkRenderPassCreateInfo2-pDependencies-03060", 48}, { {"For any element of pDependencies where its srcSubpass member equals its dstSubpass member, if the viewMask member of the corresponding element of pSubpasses includes more than one bit, its dependencyFlags member must include VK_DEPENDENCY_VIEW_LOCAL_BIT", 253}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkRenderPassCreateInfo2-pDependencies-03054", 48}, { {"For each element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be VK_PIPELINE_STAGE_ALL_COMMANDS_BIT or a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass", 305}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkRenderPassCreateInfo2-pDependencies-03055", 48}, { {"For each element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be VK_PIPELINE_STAGE_ALL_COMMANDS_BIT or a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass", 310}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkRenderPassCreateInfo2-pDependencies-03060", 48}, { {"For each element of pDependencies where its srcSubpass member equals its dstSubpass member, if the viewMask member of the corresponding element of pSubpasses includes more than one bit, its dependencyFlags member must include VK_DEPENDENCY_VIEW_LOCAL_BIT", 254}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo2-pDependencies-parameter", 52}, { {"If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency2 structures", 135}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo2-pNext-pNext", 40}, { {"pNext must be NULL", 18}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkRenderPassCreateInfo2-pSubpasses-06473", 45}, { {"If the pSubpasses pNext chain includes a VkSubpassDescriptionDepthStencilResolve structure and the pDepthStencilResolveAttachment member is not NULL and does not have the value VK_ATTACHMENT_UNUSED, then attachment must be less than attachmentCount", 248}, { "chapters/renderpass.html", 24} } }, @@ -2743,7 +2762,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkResolveImageInfo2-dstImage-00276", 39}, { {"If dstImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, dstOffset.y must be 0 and extent.height must be 1", 125}, { "chapters/copies.html", 20} } }, { {"VUID-VkResolveImageInfo2-dstImage-00278", 39}, { {"If dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, dstOffset.z must be 0 and extent.depth must be 1", 144}, { "chapters/copies.html", 20} } }, { {"VUID-VkResolveImageInfo2-dstImage-02003", 39}, { {"The format features of dstImage must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT", 83}, { "chapters/copies.html", 20} } }, - { {"VUID-VkResolveImageInfo2-dstImage-06764", 39}, { {"dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag", 79}, { "chapters/copies.html", 20} } }, + { {"VUID-VkResolveImageInfo2-dstImage-06764", 39}, { {"dstImage must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 87}, { "chapters/copies.html", 20} } }, { {"VUID-VkResolveImageInfo2-dstImage-06765", 39}, { {"The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT", 79}, { "chapters/copies.html", 20} } }, { {"VUID-VkResolveImageInfo2-dstImage-parameter", 43}, { {"dstImage must be a valid VkImage handle", 39}, { "chapters/copies.html", 20} } }, { {"VUID-VkResolveImageInfo2-dstImageLayout-00262", 45}, { {"dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice", 149}, { "chapters/copies.html", 20} } }, @@ -2767,7 +2786,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkResolveImageInfo2-srcImage-01386", 39}, { {"srcImage and dstImage must have been created with the same image format", 71}, { "chapters/copies.html", 20} } }, { {"VUID-VkResolveImageInfo2-srcImage-04446", 39}, { {"If dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.layerCount must be 1", 111}, { "chapters/copies.html", 20} } }, { {"VUID-VkResolveImageInfo2-srcImage-04447", 39}, { {"If dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, dstSubresource.baseArrayLayer must be 0 and dstSubresource.layerCount must be 1", 155}, { "chapters/copies.html", 20} } }, - { {"VUID-VkResolveImageInfo2-srcImage-06762", 39}, { {"srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag", 79}, { "chapters/copies.html", 20} } }, + { {"VUID-VkResolveImageInfo2-srcImage-06762", 39}, { {"srcImage must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 87}, { "chapters/copies.html", 20} } }, { {"VUID-VkResolveImageInfo2-srcImage-06763", 39}, { {"The format features of srcImage must contain VK_FORMAT_FEATURE_TRANSFER_SRC_BIT", 79}, { "chapters/copies.html", 20} } }, { {"VUID-VkResolveImageInfo2-srcImage-parameter", 43}, { {"srcImage must be a valid VkImage handle", 39}, { "chapters/copies.html", 20} } }, { {"VUID-VkResolveImageInfo2-srcImageLayout-00260", 45}, { {"srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice", 149}, { "chapters/copies.html", 20} } }, @@ -2808,7 +2827,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkSamplerCreateInfo-mipLodBias-01069", 41}, { {"The absolute value of mipLodBias must be less than or equal to VkPhysicalDeviceLimits::maxSamplerLodBias", 104}, { "chapters/samplers.html", 22} } }, { {"VUID-VkSamplerCreateInfo-mipmapMode-parameter", 45}, { {"mipmapMode must be a valid VkSamplerMipmapMode value", 52}, { "chapters/samplers.html", 22} } }, { {"VUID-VkSamplerCreateInfo-pNext-06726", 36}, { {"If the samplerFilterMinmax feature is not enabled and the pNext chain includes a VkSamplerReductionModeCreateInfo structure, then the sampler reduction mode must be VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE", 207}, { "chapters/samplers.html", 22} } }, - { {"VUID-VkSamplerCreateInfo-pNext-pNext", 36}, { {"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 VkSamplerCustomBorderColorCreateInfoEXT, VkSamplerReductionModeCreateInfo, or VkSamplerYcbcrConversionInfo", 237}, { "chapters/samplers.html", 22} } }, + { {"VUID-VkSamplerCreateInfo-pNext-pNext", 36}, { {"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 VkDebugUtilsObjectNameInfoEXT, VkSamplerCustomBorderColorCreateInfoEXT, VkSamplerReductionModeCreateInfo, or VkSamplerYcbcrConversionInfo", 268}, { "chapters/samplers.html", 22} } }, { {"VUID-VkSamplerCreateInfo-sType-sType", 36}, { {"sType must be VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO", 51}, { "chapters/samplers.html", 22} } }, { {"VUID-VkSamplerCreateInfo-sType-unique", 37}, { {"The sType value of each structure in the pNext chain must be unique", 67}, { "chapters/samplers.html", 22} } }, { {"VUID-VkSamplerCreateInfo-unnormalizedCoordinates-01072", 54}, { {"If unnormalizedCoordinates is VK_TRUE, minFilter and magFilter must be equal", 76}, { "chapters/samplers.html", 22} } }, @@ -2845,7 +2864,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkSamplerYcbcrConversionCreateInfo-yChromaOffset-parameter", 63}, { {"yChromaOffset must be a valid VkChromaLocation value", 52}, { "chapters/samplers.html", 22} } }, { {"VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-01655", 56}, { {"If ycbcrModel is not VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, then components.r, components.g, and components.b must correspond to components of the format; that is, components.r, components.g, and components.b must not be VK_COMPONENT_SWIZZLE_ZERO or VK_COMPONENT_SWIZZLE_ONE, and must not correspond to a component containing zero or one as a consequence of component substitution", 389}, { "chapters/samplers.html", 22} } }, { {"VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrModel-parameter", 60}, { {"ycbcrModel must be a valid VkSamplerYcbcrModelConversion value", 62}, { "chapters/samplers.html", 22} } }, - { {"VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-02748", 56}, { {"If ycbcrRange is VK_SAMPLER_YCBCR_RANGE_ITU_NARROW then the R, G and B components obtained by applying the component swizzle to format must each have a bit-depth greater than or equal to 8", 188}, { "chapters/samplers.html", 22} } }, + { {"VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-02748", 56}, { {"If ycbcrRange is VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, then the R, G, and B components obtained by applying the component swizzle to format must each have a bit-depth greater than or equal to 8", 190}, { "chapters/samplers.html", 22} } }, { {"VUID-VkSamplerYcbcrConversionCreateInfo-ycbcrRange-parameter", 60}, { {"ycbcrRange must be a valid VkSamplerYcbcrRange value", 52}, { "chapters/samplers.html", 22} } }, { {"VUID-VkSamplerYcbcrConversionImageFormatProperties-sType-sType", 62}, { {"sType must be VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES", 80}, { "chapters/capabilities.html", 26} } }, { {"VUID-VkSamplerYcbcrConversionInfo-conversion-parameter", 54}, { {"conversion must be a valid VkSamplerYcbcrConversion handle", 58}, { "chapters/samplers.html", 22} } }, @@ -3034,15 +3053,16 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkSubpassDescription-attachment-06921", 42}, { {"If the attachment member of an element of pInputAttachments is not VK_ATTACHMENT_UNUSED, its layout member must not be VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR", 157}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription-attachment-06922", 42}, { {"If the attachment member of an element of pColorAttachments is not VK_ATTACHMENT_UNUSED, its layout member must not be VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR", 156}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription-attachment-06923", 42}, { {"If the attachment member of an element of pResolveAttachments is not VK_ATTACHMENT_UNUSED, its layout member must not be VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR", 158}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkSubpassDescription-colorAttachmentCount-00845", 52}, { {"colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments", 94}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkSubpassDescription-colorAttachmentCount-00845", 52}, { {"colorAttachmentCount must be less than or equal to maxColorAttachments", 70}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription-flags-zerobitmask", 43}, { {"flags must be 0", 15}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription-inputAttachmentCount-05053", 52}, { {"inputAttachmentCount must be less than or equal to maxSubpassInputAttachments", 77}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkSubpassDescription-inputAttachmentCount-12293", 52}, { {"inputAttachmentCount must be less than or equal to maxPerStageDescriptorInputAttachments", 88}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription-layout-02519", 38}, { {"If any attachment is used by more than one VkAttachmentReference member, then each use must use the same layout", 111}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription-loadOp-00846", 38}, { {"If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then loadOp must not be VK_ATTACHMENT_LOAD_OP_CLEAR", 228}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription-pColorAttachments-02648", 49}, { {"All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT", 173}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription-pColorAttachments-09430", 49}, { {"All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count", 102}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription-pColorAttachments-parameter", 53}, { {"If colorAttachmentCount is not 0, pColorAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference structures", 150}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkSubpassDescription-pDepthStencilAttachment-01418", 55}, { {"If pDepthStencilAttachment is not VK_ATTACHMENT_UNUSED and any attachments in pColorAttachments are not VK_ATTACHMENT_UNUSED, they must have the same sample count", 162}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkSubpassDescription-pDepthStencilAttachment-01418", 55}, { {"all attachments in pDepthStencilAttachment and pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count", 130}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription-pDepthStencilAttachment-02650", 55}, { {"If pDepthStencilAttachment is not NULL and the attachment is not VK_ATTACHMENT_UNUSED then it must have an image format whose potential format features contain VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT", 206}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription-pDepthStencilAttachment-04438", 55}, { {"pDepthStencilAttachment and pColorAttachments must not contain references to the same attachment", 96}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription-pDepthStencilAttachment-parameter", 59}, { {"If pDepthStencilAttachment is not NULL, pDepthStencilAttachment must be a valid pointer to a valid VkAttachmentReference structure", 130}, { "chapters/renderpass.html", 24} } }, @@ -3077,12 +3097,13 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkSubpassDescription2-attachment-06921", 43}, { {"If the attachment member of an element of pInputAttachments is not VK_ATTACHMENT_UNUSED, its layout member must not be VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR", 157}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription2-attachment-06922", 43}, { {"If the attachment member of an element of pColorAttachments is not VK_ATTACHMENT_UNUSED, its layout member must not be VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR", 156}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription2-attachment-06923", 43}, { {"If the attachment member of an element of pResolveAttachments is not VK_ATTACHMENT_UNUSED, its layout member must not be VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR", 158}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkSubpassDescription2-colorAttachmentCount-03063", 53}, { {"colorAttachmentCount must be less than or equal to VkPhysicalDeviceLimits::maxColorAttachments", 94}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkSubpassDescription2-colorAttachmentCount-00845", 53}, { {"colorAttachmentCount must be less than or equal to maxColorAttachments", 70}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription2-flags-zerobitmask", 44}, { {"flags must be 0", 15}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription2-inputAttachmentCount-05058", 53}, { {"inputAttachmentCount must be less than or equal to maxSubpassInputAttachments", 77}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkSubpassDescription2-inputAttachmentCount-12293", 53}, { {"inputAttachmentCount must be less than or equal to maxPerStageDescriptorInputAttachments", 88}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription2-layout-02528", 39}, { {"If any attachment is used by more than one VkAttachmentReference2 member, then each use must use the same layout", 112}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkSubpassDescription2-loadOp-03064", 39}, { {"If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then loadOp must not be VK_ATTACHMENT_LOAD_OP_CLEAR", 228}, { "chapters/renderpass.html", 24} } }, - { {"VUID-VkSubpassDescription2-multisampledRenderToSingleSampled-06872", 66}, { {"All attachments in pDepthStencilAttachment or pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count", 129}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkSubpassDescription2-loadOp-00846", 39}, { {"If the first use of an attachment in this render pass is as an input attachment, and the attachment is not also used as a color or depth/stencil attachment in the same subpass, then loadOp must not be VK_ATTACHMENT_LOAD_OP_CLEAR", 228}, { "chapters/renderpass.html", 24} } }, + { {"VUID-VkSubpassDescription2-multisampledRenderToSingleSampled-06872", 66}, { {"all attachments in pDepthStencilAttachment and pColorAttachments that are not VK_ATTACHMENT_UNUSED must have the same sample count", 130}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription2-multiview-06558", 42}, { {"If the multiview feature is not enabled, viewMask must be 0", 59}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription2-pColorAttachments-02898", 50}, { {"All attachments in pColorAttachments that are not VK_ATTACHMENT_UNUSED must have image formats whose potential format features contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT", 173}, { "chapters/renderpass.html", 24} } }, { {"VUID-VkSubpassDescription2-pColorAttachments-parameter", 54}, { {"If colorAttachmentCount is not 0, pColorAttachments must be a valid pointer to an array of colorAttachmentCount valid VkAttachmentReference2 structures", 151}, { "chapters/renderpass.html", 24} } }, @@ -3227,14 +3248,14 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkWriteDescriptorSet-descriptorType-00327", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minUniformBufferOffsetAlignment", 227}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkWriteDescriptorSet-descriptorType-00328", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the offset member of each element of pBufferInfo must be a multiple of VkPhysicalDeviceLimits::minStorageBufferOffsetAlignment", 227}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkWriteDescriptorSet-descriptorType-00329", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, and the buffer member of any element of pBufferInfo is the handle of a non-sparse buffer, then that buffer must be bound completely and contiguously to a single VkDeviceMemory object", 362}, { "chapters/descriptorsets.html", 28} } }, - { {"VUID-VkWriteDescriptorSet-descriptorType-00330", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT set", 216}, { "chapters/descriptorsets.html", 28} } }, - { {"VUID-VkWriteDescriptorSet-descriptorType-00331", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with VK_BUFFER_USAGE_STORAGE_BUFFER_BIT set", 216}, { "chapters/descriptorsets.html", 28} } }, + { {"VUID-VkWriteDescriptorSet-descriptorType-00330", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with the VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT usage flag set", 231}, { "chapters/descriptorsets.html", 28} } }, + { {"VUID-VkWriteDescriptorSet-descriptorType-00331", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the buffer member of each element of pBufferInfo must have been created with the VK_BUFFER_USAGE_STORAGE_BUFFER_BIT usage flag set", 231}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkWriteDescriptorSet-descriptorType-00332", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER or VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxUniformBufferRange", 275}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkWriteDescriptorSet-descriptorType-00333", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_BUFFER or VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, the range member of each element of pBufferInfo, or the effective range if range is VK_WHOLE_SIZE, must be less than or equal to VkPhysicalDeviceLimits::maxStorageBufferRange", 275}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkWriteDescriptorSet-descriptorType-00336", 46}, { {"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", 193}, { "chapters/descriptorsets.html", 28} } }, - { {"VUID-VkWriteDescriptorSet-descriptorType-00337", 46}, { {"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", 209}, { "chapters/descriptorsets.html", 28} } }, - { {"VUID-VkWriteDescriptorSet-descriptorType-00338", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT set", 176}, { "chapters/descriptorsets.html", 28} } }, - { {"VUID-VkWriteDescriptorSet-descriptorType-00339", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, the imageView member of each element of pImageInfo must have been created with VK_IMAGE_USAGE_STORAGE_BIT set", 164}, { "chapters/descriptorsets.html", 28} } }, + { {"VUID-VkWriteDescriptorSet-descriptorType-00337", 46}, { {"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 the VK_IMAGE_USAGE_SAMPLED_BIT usage flag set", 224}, { "chapters/descriptorsets.html", 28} } }, + { {"VUID-VkWriteDescriptorSet-descriptorType-00338", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must have been created with the VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage flag set", 191}, { "chapters/descriptorsets.html", 28} } }, + { {"VUID-VkWriteDescriptorSet-descriptorType-00339", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, the imageView member of each element of pImageInfo must have been created with the VK_IMAGE_USAGE_STORAGE_BIT usage flag set", 179}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkWriteDescriptorSet-descriptorType-01946", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, then the imageView member of each pImageInfo element must have been created without a VkSamplerYcbcrConversionInfo structure in its pNext chain", 198}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkWriteDescriptorSet-descriptorType-01948", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and dstSet was allocated with a layout that included immutable samplers for dstBinding, then the imageView member of each element of pImageInfo which corresponds to an immutable sampler that enables sampler Y'CBCR conversion must have been created with a VkSamplerYcbcrConversionInfo structure in its pNext chain with an identically defined VkSamplerYcbcrConversionInfo to the corresponding immutable sampler", 472}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkWriteDescriptorSet-descriptorType-02738", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and if any element of pImageInfo has an imageView member that was created with a VkSamplerYcbcrConversionInfo structure in its pNext chain, then dstSet must have been allocated with a layout that included immutable samplers for dstBinding, and the corresponding immutable sampler must have been created with an identically defined VkSamplerYcbcrConversionInfo object", 430}, { "chapters/descriptorsets.html", 28} } }, @@ -3247,7 +3268,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-VkWriteDescriptorSet-descriptorType-04150", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER the imageLayout member of each element of pImageInfo must be a member of the list given in Combined Image Sampler", 176}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkWriteDescriptorSet-descriptorType-04151", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT the imageLayout member of each element of pImageInfo must be a member of the list given in Input Attachment", 164}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkWriteDescriptorSet-descriptorType-04152", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE the imageLayout member of each element of pImageInfo must be a member of the list given in Storage Image", 158}, { "chapters/descriptorsets.html", 28} } }, - { {"VUID-VkWriteDescriptorSet-descriptorType-07683", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, the imageView member of each element of pImageInfo must not be VK_NULL_HANDLE", 135}, { "chapters/descriptorsets.html", 28} } }, + { {"VUID-VkWriteDescriptorSet-descriptorType-07683", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, then the imageView member of each element of pImageInfo must not be VK_NULL_HANDLE", 140}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkWriteDescriptorSet-descriptorType-08765", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, the pTexelBufferView buffer view usage must include VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT", 154}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkWriteDescriptorSet-descriptorType-08766", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, the pTexelBufferView buffer view usage must include VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT", 154}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-VkWriteDescriptorSet-descriptorType-09506", 46}, { {"If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, dstSet was allocated with a layout that included immutable samplers for dstBinding, and those samplers enable sampler Y'CBCR conversion, then imageView must not be VK_NULL_HANDLE", 242}, { "chapters/descriptorsets.html", 28} } }, @@ -3329,7 +3350,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkBindBufferMemory-buffer-07459", 36}, { {"buffer must not have been bound to a memory object", 50}, { "chapters/resources.html", 23} } }, { {"VUID-vkBindBufferMemory-buffer-parameter", 40}, { {"buffer must be a valid VkBuffer handle", 38}, { "chapters/resources.html", 23} } }, { {"VUID-vkBindBufferMemory-buffer-parent", 37}, { {"buffer must have been created, allocated, or retrieved from device", 66}, { "chapters/resources.html", 23} } }, - { {"VUID-vkBindBufferMemory-bufferDeviceAddress-03339", 49}, { {"If the VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress feature is enabled and buffer was created with the VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT bit set, memory must have been allocated with the VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT bit set", 260}, { "chapters/resources.html", 23} } }, + { {"VUID-vkBindBufferMemory-bufferDeviceAddress-03339", 49}, { {"If the VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddress feature is enabled and buffer was created with the VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT usage flag set, memory must have been allocated with the VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT bit set", 267}, { "chapters/resources.html", 23} } }, { {"VUID-vkBindBufferMemory-bufferDeviceAddressCaptureReplay-09200", 62}, { {"If the VkPhysicalDeviceBufferDeviceAddressFeatures::bufferDeviceAddressCaptureReplay feature is enabled and buffer was created with the VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT bit set, memory must have been allocated with the VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT bit set", 297}, { "chapters/resources.html", 23} } }, { {"VUID-vkBindBufferMemory-device-parameter", 40}, { {"device must be a valid VkDevice handle", 38}, { "chapters/resources.html", 23} } }, { {"VUID-vkBindBufferMemory-memory-01035", 36}, { {"memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer", 202}, { "chapters/resources.html", 23} } }, @@ -3401,17 +3422,17 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdBeginRenderPass-dstStageMask-06452", 44}, { {"The dstStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from", 321}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass-framebuffer-02532", 43}, { {"For any attachment in framebuffer that is used by renderPass and is bound to memory locations that are also bound to another attachment used by renderPass, and if at least one of those uses causes either attachment to be written to, both attachments must have had the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT set", 311}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass-framebuffer-09045", 43}, { {"If any attachments specified in framebuffer are used by renderPass and are bound to overlapping memory locations, there must be only one that is used as a color attachment, depth/stencil, or resolve attachment in any subpass", 224}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass-initialLayout-00895", 45}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT", 499}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass-initialLayout-00897", 45}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", 529}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass-initialLayout-00898", 45}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_SRC_BIT", 491}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass-initialLayout-00899", 45}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_DST_BIT", 491}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass-initialLayout-00895", 45}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT usage flag set", 494}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass-initialLayout-00897", 45}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage flags set", 525}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass-initialLayout-00898", 45}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 486}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass-initialLayout-00899", 45}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 486}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass-initialLayout-00900", 45}, { {"If the initialLayout member of any of the VkAttachmentDescription structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is not VK_IMAGE_LAYOUT_UNDEFINED, then each such initialLayout must be equal to the current layout of the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin", 395}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass-initialLayout-01758", 45}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 687}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass-initialLayout-02842", 45}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 641}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass-initialLayout-01758", 45}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 682}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass-initialLayout-02842", 45}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 636}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass-pRenderPassBegin-parameter", 52}, { {"pRenderPassBegin must be a valid pointer to a valid VkRenderPassBeginInfo structure", 83}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass-renderpass", 36}, { {"This command must only be called outside of a render pass instance", 66}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass-srcStageMask-06451", 44}, { {"The srcStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from", 321}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass-stencilInitialLayout-02843", 52}, { {"If any of the stencilInitialLayout or stencilFinalLayout member of the VkAttachmentDescriptionStencilLayout structures or the stencilLayout member of the VkAttachmentReferenceStencilLayout structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 602}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass-stencilInitialLayout-02843", 52}, { {"If any of the stencilInitialLayout or stencilFinalLayout member of the VkAttachmentDescriptionStencilLayout structures or the stencilLayout member of the VkAttachmentReferenceStencilLayout structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 597}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass2-bufferlevel", 38}, { {"commandBuffer must be a primary VkCommandBuffer", 47}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass2-commandBuffer-cmdpool", 48}, { {"The VkCommandPool that commandBuffer was allocated from must support VK_QUEUE_GRAPHICS_BIT operations", 101}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass2-commandBuffer-parameter", 50}, { {"commandBuffer must be a valid VkCommandBuffer handle", 52}, { "chapters/renderpass.html", 24} } }, @@ -3420,18 +3441,18 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdBeginRenderPass2-framebuffer-02533", 44}, { {"For any attachment in framebuffer that is used by renderPass and is bound to memory locations that are also bound to another attachment used by renderPass, and if at least one of those uses causes either attachment to be written to, both attachments must have had the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT set", 311}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass2-framebuffer-02779", 44}, { {"Both the framebuffer and renderPass members of pRenderPassBegin must have been created on the same VkDevice that commandBuffer was allocated on", 143}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass2-framebuffer-09046", 44}, { {"If any attachments specified in framebuffer are used by renderPass and are bound to overlapping memory locations, there must be only one that is used as a color attachment, depth/stencil, or resolve attachment in any subpass", 224}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass2-initialLayout-02844", 46}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 641}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass2-initialLayout-03094", 46}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT", 499}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass2-initialLayout-03096", 46}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 687}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass2-initialLayout-03097", 46}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT", 529}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass2-initialLayout-03098", 46}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_SRC_BIT", 491}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass2-initialLayout-03099", 46}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_TRANSFER_DST_BIT", 491}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass2-initialLayout-02844", 46}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 636}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass2-initialLayout-03094", 46}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT usage flag set", 494}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass2-initialLayout-03096", 46}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 682}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass2-initialLayout-03097", 46}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT usage flags set", 525}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass2-initialLayout-03098", 46}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 486}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass2-initialLayout-03099", 46}, { {"If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 486}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass2-initialLayout-03100", 46}, { {"If the initialLayout member of any of the VkAttachmentDescription structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is not VK_IMAGE_LAYOUT_UNDEFINED, then each such initialLayout must be equal to the current layout of the corresponding attachment image subresource of the framebuffer specified in the framebuffer member of pRenderPassBegin", 395}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass2-pRenderPassBegin-parameter", 53}, { {"pRenderPassBegin must be a valid pointer to a valid VkRenderPassBeginInfo structure", 83}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass2-pSubpassBeginInfo-parameter", 54}, { {"pSubpassBeginInfo must be a valid pointer to a valid VkSubpassBeginInfo structure", 81}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass2-renderpass", 37}, { {"This command must only be called outside of a render pass instance", 66}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBeginRenderPass2-srcStageMask-06453", 45}, { {"The srcStageMask members of any element of the pDependencies member of VkRenderPassCreateInfo used to create renderPass must be supported by the capabilities of the queue family identified by the queueFamilyIndex member of the VkCommandPoolCreateInfo used to create the command pool which commandBuffer was allocated from", 321}, { "chapters/renderpass.html", 24} } }, - { {"VUID-vkCmdBeginRenderPass2-stencilInitialLayout-02845", 53}, { {"If any of the stencilInitialLayout or stencilFinalLayout member of the VkAttachmentDescriptionStencilLayout structures or the stencilLayout member of the VkAttachmentReferenceStencilLayout structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT", 602}, { "chapters/renderpass.html", 24} } }, + { {"VUID-vkCmdBeginRenderPass2-stencilInitialLayout-02845", 53}, { {"If any of the stencilInitialLayout or stencilFinalLayout member of the VkAttachmentDescriptionStencilLayout structures or the stencilLayout member of the VkAttachmentReferenceStencilLayout structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with the VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT usage flag set", 597}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkCmdBindDescriptorSets-commandBuffer-cmdpool", 50}, { {"The VkCommandPool that commandBuffer was allocated from must support VK_QUEUE_COMPUTE_BIT, or VK_QUEUE_GRAPHICS_BIT operations", 126}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-vkCmdBindDescriptorSets-commandBuffer-parameter", 52}, { {"commandBuffer must be a valid VkCommandBuffer handle", 52}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-vkCmdBindDescriptorSets-commandBuffer-recording", 52}, { {"commandBuffer must be in the recording state", 44}, { "chapters/descriptorsets.html", 28} } }, @@ -3451,7 +3472,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdBindDescriptorSets-pipelineBindPoint-00361", 52}, { {"pipelineBindPoint must be supported by the commandBuffer's parent VkCommandPool's queue family", 94}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-vkCmdBindDescriptorSets-pipelineBindPoint-parameter", 56}, { {"pipelineBindPoint must be a valid VkPipelineBindPoint value", 59}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-vkCmdBindIndexBuffer-None-09493", 36}, { {"buffer must not be VK_NULL_HANDLE", 33}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdBindIndexBuffer-buffer-08784", 38}, { {"buffer must have been created with the VK_BUFFER_USAGE_INDEX_BUFFER_BIT flag", 76}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdBindIndexBuffer-buffer-08784", 38}, { {"buffer must have been created with the VK_BUFFER_USAGE_INDEX_BUFFER_BIT usage flag set", 86}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdBindIndexBuffer-buffer-08785", 38}, { {"If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 107}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdBindIndexBuffer-buffer-parameter", 42}, { {"If buffer is not VK_NULL_HANDLE, buffer must be a valid VkBuffer handle", 71}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdBindIndexBuffer-commandBuffer-cmdpool", 47}, { {"The VkCommandPool that commandBuffer was allocated from must support VK_QUEUE_GRAPHICS_BIT operations", 101}, { "chapters/drawing.html", 21} } }, @@ -3482,7 +3503,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdBindVertexBuffers-commonparent", 40}, { {"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", 171}, { "chapters/fxvertex.html", 22} } }, { {"VUID-vkCmdBindVertexBuffers-firstBinding-00624", 46}, { {"firstBinding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings", 77}, { "chapters/fxvertex.html", 22} } }, { {"VUID-vkCmdBindVertexBuffers-firstBinding-00625", 46}, { {"The sum of firstBinding and bindingCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings", 117}, { "chapters/fxvertex.html", 22} } }, - { {"VUID-vkCmdBindVertexBuffers-pBuffers-00627", 42}, { {"All elements of pBuffers must have been created with the VK_BUFFER_USAGE_VERTEX_BUFFER_BIT flag", 95}, { "chapters/fxvertex.html", 22} } }, + { {"VUID-vkCmdBindVertexBuffers-pBuffers-00627", 42}, { {"All elements of pBuffers must have been created with the VK_BUFFER_USAGE_VERTEX_BUFFER_BIT usage flag set", 105}, { "chapters/fxvertex.html", 22} } }, { {"VUID-vkCmdBindVertexBuffers-pBuffers-00628", 42}, { {"Each element of pBuffers that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object", 119}, { "chapters/fxvertex.html", 22} } }, { {"VUID-vkCmdBindVertexBuffers-pBuffers-04001", 42}, { {"If the nullDescriptor feature is not enabled, all elements of pBuffers must not be VK_NULL_HANDLE", 97}, { "chapters/fxvertex.html", 22} } }, { {"VUID-vkCmdBindVertexBuffers-pBuffers-04002", 42}, { {"If an element of pBuffers is VK_NULL_HANDLE, then the corresponding element of pOffsets must be zero", 100}, { "chapters/fxvertex.html", 22} } }, @@ -3497,7 +3518,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdBindVertexBuffers2-commonparent", 41}, { {"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", 171}, { "chapters/fxvertex.html", 22} } }, { {"VUID-vkCmdBindVertexBuffers2-firstBinding-03355", 47}, { {"firstBinding must be less than VkPhysicalDeviceLimits::maxVertexInputBindings", 77}, { "chapters/fxvertex.html", 22} } }, { {"VUID-vkCmdBindVertexBuffers2-firstBinding-03356", 47}, { {"The sum of firstBinding and bindingCount must be less than or equal to VkPhysicalDeviceLimits::maxVertexInputBindings", 117}, { "chapters/fxvertex.html", 22} } }, - { {"VUID-vkCmdBindVertexBuffers2-pBuffers-03359", 43}, { {"All elements of pBuffers must have been created with the VK_BUFFER_USAGE_VERTEX_BUFFER_BIT flag", 95}, { "chapters/fxvertex.html", 22} } }, + { {"VUID-vkCmdBindVertexBuffers2-pBuffers-03359", 43}, { {"All elements of pBuffers must have been created with the VK_BUFFER_USAGE_VERTEX_BUFFER_BIT usage flag set", 105}, { "chapters/fxvertex.html", 22} } }, { {"VUID-vkCmdBindVertexBuffers2-pBuffers-03360", 43}, { {"Each element of pBuffers that is non-sparse must be bound completely and contiguously to a single VkDeviceMemory object", 119}, { "chapters/fxvertex.html", 22} } }, { {"VUID-vkCmdBindVertexBuffers2-pBuffers-04111", 43}, { {"If the nullDescriptor feature is not enabled, all elements of pBuffers must not be VK_NULL_HANDLE", 97}, { "chapters/fxvertex.html", 22} } }, { {"VUID-vkCmdBindVertexBuffers2-pBuffers-04112", 43}, { {"If an element of pBuffers is VK_NULL_HANDLE, then the corresponding element of pOffsets must be zero", 100}, { "chapters/fxvertex.html", 22} } }, @@ -3518,7 +3539,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdBlitImage-commandBuffer-parameter", 43}, { {"commandBuffer must be a valid VkCommandBuffer handle", 52}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdBlitImage-commandBuffer-recording", 43}, { {"commandBuffer must be in the recording state", 44}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdBlitImage-commonparent", 32}, { {"Each of commandBuffer, dstImage, and srcImage must have been created, allocated, or retrieved from the same VkDevice", 116}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdBlitImage-dstImage-00224", 34}, { {"dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag", 79}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdBlitImage-dstImage-00224", 34}, { {"dstImage must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 87}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdBlitImage-dstImage-00225", 34}, { {"If dstImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 109}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdBlitImage-dstImage-00234", 34}, { {"dstImage must have been created with a samples value of VK_SAMPLE_COUNT_1_BIT", 77}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdBlitImage-dstImage-00250", 34}, { {"If dstImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, dstOffsets[0].y must be 0 and dstOffsets[1].y must be 1", 131}, { "chapters/copies.html", 20} } }, @@ -3542,7 +3563,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdBlitImage-pRegions-parameter", 38}, { {"pRegions must be a valid pointer to an array of regionCount valid VkImageBlit structures", 88}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdBlitImage-regionCount-arraylength", 43}, { {"regionCount must be greater than 0", 34}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdBlitImage-renderpass", 30}, { {"This command must only be called outside of a render pass instance", 66}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdBlitImage-srcImage-00219", 34}, { {"srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag", 79}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdBlitImage-srcImage-00219", 34}, { {"srcImage must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 87}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdBlitImage-srcImage-00220", 34}, { {"If srcImage is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 109}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdBlitImage-srcImage-00229", 34}, { {"If either of srcImage or dstImage was created with a signed integer VkFormat, the other must also have been created with a signed integer VkFormat", 146}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdBlitImage-srcImage-00230", 34}, { {"If either of srcImage or dstImage was created with an unsigned integer VkFormat, the other must also have been created with an unsigned integer VkFormat", 152}, { "chapters/copies.html", 20} } }, @@ -3601,7 +3622,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdClearColorImage-commandBuffer-parameter", 49}, { {"commandBuffer must be a valid VkCommandBuffer handle", 52}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdClearColorImage-commandBuffer-recording", 49}, { {"commandBuffer must be in the recording state", 44}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdClearColorImage-commonparent", 38}, { {"Both of commandBuffer, and image must have been created, allocated, or retrieved from the same VkDevice", 103}, { "chapters/clears.html", 20} } }, - { {"VUID-vkCmdClearColorImage-image-00002", 37}, { {"image must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag", 76}, { "chapters/clears.html", 20} } }, + { {"VUID-vkCmdClearColorImage-image-00002", 37}, { {"image must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 84}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdClearColorImage-image-00003", 37}, { {"If image is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 106}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdClearColorImage-image-00007", 37}, { {"image must not have a compressed or depth/stencil format", 56}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdClearColorImage-image-01545", 37}, { {"image must not use any of the formats that require a sampler Y'CBCR conversion", 78}, { "chapters/clears.html", 20} } }, @@ -3638,9 +3659,9 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdClearDepthStencilImage-pDepthStencil-parameter", 56}, { {"pDepthStencil must be a valid pointer to a valid VkClearDepthStencilValue structure", 83}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdClearDepthStencilImage-pRanges-01694", 46}, { {"For each VkImageSubresourceRange element of pRanges, if the levelCount member is not VK_REMAINING_MIP_LEVELS, then baseMipLevel + levelCount must be less than or equal to the mipLevels specified in VkImageCreateInfo when image was created", 238}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdClearDepthStencilImage-pRanges-01695", 46}, { {"For each VkImageSubresourceRange element of pRanges, if the layerCount member is not VK_REMAINING_ARRAY_LAYERS, then baseArrayLayer + layerCount must be less than or equal to the arrayLayers specified in VkImageCreateInfo when image was created", 244}, { "chapters/clears.html", 20} } }, - { {"VUID-vkCmdClearDepthStencilImage-pRanges-02658", 46}, { {"If the aspect member of any element of pRanges includes VK_IMAGE_ASPECT_STENCIL_BIT, and image was created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_DST_BIT must have been included in the VkImageStencilUsageCreateInfo::stencilUsage used to create image", 263}, { "chapters/clears.html", 20} } }, - { {"VUID-vkCmdClearDepthStencilImage-pRanges-02659", 46}, { {"If the aspect member of any element of pRanges includes VK_IMAGE_ASPECT_STENCIL_BIT, and image was not created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_DST_BIT must have been included in the VkImageCreateInfo::usage used to create image", 248}, { "chapters/clears.html", 20} } }, - { {"VUID-vkCmdClearDepthStencilImage-pRanges-02660", 46}, { {"If the aspect member of any element of pRanges includes VK_IMAGE_ASPECT_DEPTH_BIT, VK_IMAGE_USAGE_TRANSFER_DST_BIT must have been included in the VkImageCreateInfo::usage used to create image", 191}, { "chapters/clears.html", 20} } }, + { {"VUID-vkCmdClearDepthStencilImage-pRanges-02658", 46}, { {"If the aspect member of any element of pRanges includes VK_IMAGE_ASPECT_STENCIL_BIT, and image was created with separate stencil usage, it must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 217}, { "chapters/clears.html", 20} } }, + { {"VUID-vkCmdClearDepthStencilImage-pRanges-02659", 46}, { {"If the aspect member of any element of pRanges includes VK_IMAGE_ASPECT_STENCIL_BIT, and image was not created with separate stencil usage, the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag must have been set in the VkImageCreateInfo::usage used to create image", 258}, { "chapters/clears.html", 20} } }, + { {"VUID-vkCmdClearDepthStencilImage-pRanges-02660", 46}, { {"If the aspect member of any element of pRanges includes VK_IMAGE_ASPECT_DEPTH_BIT, image must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 167}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdClearDepthStencilImage-pRanges-parameter", 50}, { {"pRanges must be a valid pointer to an array of rangeCount valid VkImageSubresourceRange structures", 98}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdClearDepthStencilImage-rangeCount-arraylength", 55}, { {"rangeCount must be greater than 0", 33}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdClearDepthStencilImage-renderpass", 43}, { {"This command must only be called outside of a render pass instance", 66}, { "chapters/clears.html", 20} } }, @@ -3651,7 +3672,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdCopyBuffer-commandBuffer-parameter", 44}, { {"commandBuffer must be a valid VkCommandBuffer handle", 52}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBuffer-commandBuffer-recording", 44}, { {"commandBuffer must be in the recording state", 44}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBuffer-commonparent", 33}, { {"Each of commandBuffer, dstBuffer, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice", 118}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyBuffer-dstBuffer-00120", 36}, { {"dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag", 81}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyBuffer-dstBuffer-00120", 36}, { {"dstBuffer must have been created with the VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag set", 89}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBuffer-dstBuffer-00121", 36}, { {"If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 110}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBuffer-dstBuffer-parameter", 40}, { {"dstBuffer must be a valid VkBuffer handle", 41}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBuffer-dstOffset-00114", 36}, { {"The dstOffset member of each element of pRegions must be less than the size of dstBuffer", 88}, { "chapters/copies.html", 20} } }, @@ -3661,7 +3682,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdCopyBuffer-renderpass", 31}, { {"This command must only be called outside of a render pass instance", 66}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBuffer-size-00115", 31}, { {"The size member of each element of pRegions must be less than or equal to the size of srcBuffer minus srcOffset", 111}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBuffer-size-00116", 31}, { {"The size member of each element of pRegions must be less than or equal to the size of dstBuffer minus dstOffset", 111}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyBuffer-srcBuffer-00118", 36}, { {"srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag", 81}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyBuffer-srcBuffer-00118", 36}, { {"srcBuffer must have been created with the VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag set", 89}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBuffer-srcBuffer-00119", 36}, { {"If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 110}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBuffer-srcBuffer-parameter", 40}, { {"srcBuffer must be a valid VkBuffer handle", 41}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBuffer-srcOffset-00113", 36}, { {"The srcOffset member of each element of pRegions must be less than the size of srcBuffer", 88}, { "chapters/copies.html", 20} } }, @@ -3685,7 +3706,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdCopyBufferToImage-commandBuffer-parameter", 51}, { {"commandBuffer must be a valid VkCommandBuffer handle", 52}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-commandBuffer-recording", 51}, { {"commandBuffer must be in the recording state", 44}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-commonparent", 40}, { {"Each of commandBuffer, dstImage, and srcBuffer must have been created, allocated, or retrieved from the same VkDevice", 117}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyBufferToImage-dstImage-00177", 42}, { {"dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag", 79}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyBufferToImage-dstImage-00177", 42}, { {"dstImage must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 87}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-dstImage-00207", 42}, { {"For each element of pRegions, if the sum of imageOffset.x and extent.width does not equal the width of the subresource specified by imageSubresource, extent.width must be a multiple of the texel block extent width of the VkFormat of dstImage", 241}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-dstImage-00208", 42}, { {"For each element of pRegions, if the sum of imageOffset.y and extent.height does not equal the height of the subresource specified by imageSubresource, extent.height must be a multiple of the texel block extent height of the VkFormat of dstImage", 245}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-dstImage-00209", 42}, { {"For each element of pRegions, if the sum of imageOffset.z and extent.depth does not equal the depth of the subresource specified by srcSubresource, extent.depth must be a multiple of the texel block extent depth of the VkFormat of dstImage", 239}, { "chapters/copies.html", 20} } }, @@ -3693,7 +3714,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdCopyBufferToImage-dstImage-07274", 42}, { {"For each element of pRegions, imageOffset.x must be a multiple of the texel block extent width of the VkFormat of dstImage", 122}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-dstImage-07275", 42}, { {"For each element of pRegions, imageOffset.y must be a multiple of the texel block extent height of the VkFormat of dstImage", 123}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-dstImage-07276", 42}, { {"For each element of pRegions, imageOffset.z must be a multiple of the texel block extent depth of the VkFormat of dstImage", 122}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyBufferToImage-dstImage-07966", 42}, { {"If dstImage is non-sparse then the image or the specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 148}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyBufferToImage-dstImage-07966", 42}, { {"If dstImage is non-sparse then the image or each specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 149}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-dstImage-07973", 42}, { {"dstImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT", 64}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-dstImage-07975", 42}, { {"If dstImage does not have either a depth/stencil format or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the texel block size", 172}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-dstImage-07976", 42}, { {"If dstImage has a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the element size of the compatible format for the format and the aspectMask of the imageSubresource as defined in Compatible Formats of Planes of Multi-Planar Formats", 275}, { "chapters/copies.html", 20} } }, @@ -3719,7 +3740,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdCopyBufferToImage-pRegions-parameter", 46}, { {"pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures", 94}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-regionCount-arraylength", 51}, { {"regionCount must be greater than 0", 34}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-renderpass", 38}, { {"This command must only be called outside of a render pass instance", 66}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyBufferToImage-srcBuffer-00174", 43}, { {"srcBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag", 81}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyBufferToImage-srcBuffer-00174", 43}, { {"srcBuffer must have been created with the VK_BUFFER_USAGE_TRANSFER_SRC_BIT usage flag set", 89}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-srcBuffer-00176", 43}, { {"If srcBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 110}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage-srcBuffer-parameter", 47}, { {"srcBuffer must be a valid VkBuffer handle", 41}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage2-commandBuffer-01828", 48}, { {"If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcBuffer must not be a protected buffer", 129}, { "chapters/copies.html", 20} } }, @@ -3734,10 +3755,10 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdCopyBufferToImage2-pCopyBufferToImageInfo-parameter", 61}, { {"pCopyBufferToImageInfo must be a valid pointer to a valid VkCopyBufferToImageInfo2 structure", 92}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyBufferToImage2-renderpass", 39}, { {"This command must only be called outside of a render pass instance", 66}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-None-01549", 30}, { {"In a copy to or from a plane of a multi-planar image, the VkFormat of the image and plane must be compatible according to the description of compatible planes for the plane being copied", 185}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyImage-aspect-06662", 32}, { {"If the aspect member of any element of pRegions includes any flag other than VK_IMAGE_ASPECT_STENCIL_BIT or srcImage was not created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT must have been included in the VkImageCreateInfo::usage used to create srcImage", 273}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyImage-aspect-06663", 32}, { {"If the aspect member of any element of pRegions includes any flag other than VK_IMAGE_ASPECT_STENCIL_BIT or dstImage was not created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_DST_BIT must have been included in the VkImageCreateInfo::usage used to create dstImage", 273}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyImage-aspect-06664", 32}, { {"If the aspect member of any element of pRegions includes VK_IMAGE_ASPECT_STENCIL_BIT, and srcImage was created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT must have been included in the VkImageStencilUsageCreateInfo::stencilUsage used to create srcImage", 270}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyImage-aspect-06665", 32}, { {"If the aspect member of any element of pRegions includes VK_IMAGE_ASPECT_STENCIL_BIT, and dstImage was created with separate stencil usage, VK_IMAGE_USAGE_TRANSFER_DST_BIT must have been included in the VkImageStencilUsageCreateInfo::stencilUsage used to create dstImage", 270}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyImage-aspect-06662", 32}, { {"If the aspect member of any element of pRegions includes any flag other than VK_IMAGE_ASPECT_STENCIL_BIT or srcImage was not created with separate stencil usage, srcImage must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 249}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyImage-aspect-06663", 32}, { {"If the aspect member of any element of pRegions includes any flag other than VK_IMAGE_ASPECT_STENCIL_BIT or dstImage was not created with separate stencil usage, dstImage must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 249}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyImage-aspect-06664", 32}, { {"If the aspect member of any element of pRegions includes VK_IMAGE_ASPECT_STENCIL_BIT, and srcImage was created with separate stencil usage, srcImage must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 227}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyImage-aspect-06665", 32}, { {"If the aspect member of any element of pRegions includes VK_IMAGE_ASPECT_STENCIL_BIT, and dstImage was created with separate stencil usage, srcImage must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 227}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-aspectMask-00142", 36}, { {"For each element of pRegions, srcSubresource.aspectMask must specify aspects present in srcImage", 96}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-aspectMask-00143", 36}, { {"For each element of pRegions, dstSubresource.aspectMask must specify aspects present in dstImage", 96}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-commandBuffer-01825", 39}, { {"If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, srcImage must not be a protected image", 127}, { "chapters/copies.html", 20} } }, @@ -3754,7 +3775,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdCopyImage-dstImage-01792", 34}, { {"If dstImage is of type VK_IMAGE_TYPE_2D, and srcImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, extent.depth must equal dstSubresource.layerCount", 167}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-dstImage-01996", 34}, { {"The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT", 79}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-dstImage-04444", 34}, { {"If dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, dstSubresource.baseArrayLayer must be 0 and dstSubresource.layerCount must be 1", 155}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyImage-dstImage-07966", 34}, { {"If dstImage is non-sparse then the image or the specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 148}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyImage-dstImage-07966", 34}, { {"If dstImage is non-sparse then the image or each specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 149}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-dstImage-08714", 34}, { {"If dstImage has a multi-planar format, then for each element of pRegions, dstSubresource.aspectMask must be a single valid multi-planar aspect mask bit", 151}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-dstImage-parameter", 38}, { {"dstImage must be a valid VkImage handle", 39}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-dstImageLayout-00133", 40}, { {"dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice", 149}, { "chapters/copies.html", 20} } }, @@ -3791,7 +3812,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdCopyImage-srcImage-01995", 34}, { {"The format features of srcImage must contain VK_FORMAT_FEATURE_TRANSFER_SRC_BIT", 79}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-srcImage-04443", 34}, { {"If srcImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.baseArrayLayer must be 0 and srcSubresource.layerCount must be 1", 155}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-srcImage-07743", 34}, { {"If srcImage and dstImage have a different VkImageType, one must be VK_IMAGE_TYPE_3D and the other must be VK_IMAGE_TYPE_2D", 122}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyImage-srcImage-07966", 34}, { {"If srcImage is non-sparse then the image or the specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 148}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyImage-srcImage-07966", 34}, { {"If srcImage is non-sparse then the image or each specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 149}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-srcImage-08713", 34}, { {"If srcImage has a multi-planar format, then for each element of pRegions, srcSubresource.aspectMask must be a single valid multi-planar aspect mask bit", 151}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-srcImage-08793", 34}, { {"If srcImage and dstImage have the same VkImageType, for each element of pRegions, the layerCount members of srcSubresource or dstSubresource must match", 151}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImage-srcImage-09247", 34}, { {"If the VkFormat of each of srcImage and dstImage is a compressed image format, the formats must have the same texel block extent", 128}, { "chapters/copies.html", 20} } }, @@ -3828,7 +3849,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdCopyImageToBuffer-commandBuffer-parameter", 51}, { {"commandBuffer must be a valid VkCommandBuffer handle", 52}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-commandBuffer-recording", 51}, { {"commandBuffer must be in the recording state", 44}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-commonparent", 40}, { {"Each of commandBuffer, dstBuffer, and srcImage must have been created, allocated, or retrieved from the same VkDevice", 117}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyImageToBuffer-dstBuffer-00191", 43}, { {"dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag", 81}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyImageToBuffer-dstBuffer-00191", 43}, { {"dstBuffer must have been created with the VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag set", 89}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-dstBuffer-00192", 43}, { {"If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 110}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-dstBuffer-parameter", 47}, { {"dstBuffer must be a valid VkBuffer handle", 41}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-imageOffset-07747", 45}, { {"The imageOffset and imageExtent members of each element of pRegions must respect the image transfer granularity requirements of commandBuffer's command pool's queue family, as described in VkQueueFamilyProperties", 212}, { "chapters/copies.html", 20} } }, @@ -3843,7 +3864,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdCopyImageToBuffer-pRegions-parameter", 46}, { {"pRegions must be a valid pointer to an array of regionCount valid VkBufferImageCopy structures", 94}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-regionCount-arraylength", 51}, { {"regionCount must be greater than 0", 34}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-renderpass", 38}, { {"This command must only be called outside of a render pass instance", 66}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyImageToBuffer-srcImage-00186", 42}, { {"srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag", 79}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyImageToBuffer-srcImage-00186", 42}, { {"srcImage must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 87}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-srcImage-00207", 42}, { {"For each element of pRegions, if the sum of imageOffset.x and extent.width does not equal the width of the subresource specified by imageSubresource, extent.width must be a multiple of the texel block extent width of the VkFormat of srcImage", 241}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-srcImage-00208", 42}, { {"For each element of pRegions, if the sum of imageOffset.y and extent.height does not equal the height of the subresource specified by imageSubresource, extent.height must be a multiple of the texel block extent height of the VkFormat of srcImage", 245}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-srcImage-00209", 42}, { {"For each element of pRegions, if the sum of imageOffset.z and extent.depth does not equal the depth of the subresource specified by srcSubresource, extent.depth must be a multiple of the texel block extent depth of the VkFormat of srcImage", 239}, { "chapters/copies.html", 20} } }, @@ -3851,7 +3872,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdCopyImageToBuffer-srcImage-07274", 42}, { {"For each element of pRegions, imageOffset.x must be a multiple of the texel block extent width of the VkFormat of srcImage", 122}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-srcImage-07275", 42}, { {"For each element of pRegions, imageOffset.y must be a multiple of the texel block extent height of the VkFormat of srcImage", 123}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-srcImage-07276", 42}, { {"For each element of pRegions, imageOffset.z must be a multiple of the texel block extent depth of the VkFormat of srcImage", 122}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdCopyImageToBuffer-srcImage-07966", 42}, { {"If srcImage is non-sparse then the image or the specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 148}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdCopyImageToBuffer-srcImage-07966", 42}, { {"If srcImage is non-sparse then the image or each specified disjoint plane must be bound completely and contiguously to a single VkDeviceMemory object", 149}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-srcImage-07973", 42}, { {"srcImage must have a sample count equal to VK_SAMPLE_COUNT_1_BIT", 64}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-srcImage-07975", 42}, { {"If srcImage does not have either a depth/stencil format or a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the texel block size", 172}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdCopyImageToBuffer-srcImage-07976", 42}, { {"If srcImage has a multi-planar format, then for each element of pRegions, bufferOffset must be a multiple of the element size of the compatible format for the format and the aspectMask of the imageSubresource as defined in Compatible Formats of Planes of Multi-Planar Formats", 275}, { "chapters/copies.html", 20} } }, @@ -3883,16 +3904,18 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdCopyQueryPoolResults-commandBuffer-recording", 54}, { {"commandBuffer must be in the recording state", 44}, { "chapters/queries.html", 21} } }, { {"VUID-vkCmdCopyQueryPoolResults-commonparent", 43}, { {"Each of commandBuffer, dstBuffer, and queryPool must have been created, allocated, or retrieved from the same VkDevice", 118}, { "chapters/queries.html", 21} } }, { {"VUID-vkCmdCopyQueryPoolResults-dstBuffer-00824", 46}, { {"dstBuffer must have enough storage, from dstOffset, to contain the result of each query, as described here", 106}, { "chapters/queries.html", 21} } }, - { {"VUID-vkCmdCopyQueryPoolResults-dstBuffer-00825", 46}, { {"dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag", 81}, { "chapters/queries.html", 21} } }, + { {"VUID-vkCmdCopyQueryPoolResults-dstBuffer-00825", 46}, { {"dstBuffer must have been created with the VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag set", 89}, { "chapters/queries.html", 21} } }, { {"VUID-vkCmdCopyQueryPoolResults-dstBuffer-00826", 46}, { {"If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 110}, { "chapters/queries.html", 21} } }, { {"VUID-vkCmdCopyQueryPoolResults-dstBuffer-parameter", 50}, { {"dstBuffer must be a valid VkBuffer handle", 41}, { "chapters/queries.html", 21} } }, { {"VUID-vkCmdCopyQueryPoolResults-dstOffset-00819", 46}, { {"dstOffset must be less than the size of dstBuffer", 49}, { "chapters/queries.html", 21} } }, { {"VUID-vkCmdCopyQueryPoolResults-firstQuery-09436", 47}, { {"firstQuery must be less than the number of queries in queryPool", 63}, { "chapters/queries.html", 21} } }, { {"VUID-vkCmdCopyQueryPoolResults-firstQuery-09437", 47}, { {"The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool", 101}, { "chapters/queries.html", 21} } }, - { {"VUID-vkCmdCopyQueryPoolResults-flags-00822", 42}, { {"If VK_QUERY_RESULT_64_BIT is not set in flags then dstOffset and stride must be multiples of 4", 94}, { "chapters/queries.html", 21} } }, - { {"VUID-vkCmdCopyQueryPoolResults-flags-00823", 42}, { {"If VK_QUERY_RESULT_64_BIT is set in flags then dstOffset and stride must be multiples of 8", 90}, { "chapters/queries.html", 21} } }, + { {"VUID-vkCmdCopyQueryPoolResults-flags-00822", 42}, { {"If VK_QUERY_RESULT_64_BIT is not set in flags then dstOffset must be a multiple of 4", 84}, { "chapters/queries.html", 21} } }, + { {"VUID-vkCmdCopyQueryPoolResults-flags-00823", 42}, { {"If VK_QUERY_RESULT_64_BIT is set in flags then dstOffset must be a multiple of 8", 80}, { "chapters/queries.html", 21} } }, { {"VUID-vkCmdCopyQueryPoolResults-flags-parameter", 46}, { {"flags must be a valid combination of VkQueryResultFlagBits values", 65}, { "chapters/queries.html", 21} } }, { {"VUID-vkCmdCopyQueryPoolResults-queryCount-09438", 47}, { {"If queryCount is greater than 1, stride must not be zero", 56}, { "chapters/queries.html", 21} } }, + { {"VUID-vkCmdCopyQueryPoolResults-queryCount-12254", 47}, { {"If queryCount is greater than 1 and VK_QUERY_RESULT_64_BIT is not set in flags then stride must be a multiple of 4", 114}, { "chapters/queries.html", 21} } }, + { {"VUID-vkCmdCopyQueryPoolResults-queryCount-12255", 47}, { {"If queryCount is greater than 1 and VK_QUERY_RESULT_64_BIT is set in flags then stride must be a multiple of 8", 110}, { "chapters/queries.html", 21} } }, { {"VUID-vkCmdCopyQueryPoolResults-queryPool-parameter", 50}, { {"queryPool must be a valid VkQueryPool handle", 44}, { "chapters/queries.html", 21} } }, { {"VUID-vkCmdCopyQueryPoolResults-queryType-03232", 46}, { {"If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, VkPhysicalDevicePerformanceQueryPropertiesKHR::allowCommandBufferQueryCopies must be VK_TRUE", 175}, { "chapters/queries.html", 21} } }, { {"VUID-vkCmdCopyQueryPoolResults-queryType-09439", 46}, { {"If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT", 121}, { "chapters/queries.html", 21} } }, @@ -3904,9 +3927,9 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDispatch-None-02693", 29}, { {"If the VK_EXT_filter_cubic extension is not enabled and any VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, it must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY", 255}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatch-None-07288", 29}, { {"Any shader invocation executed by this command must terminate", 61}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatch-None-07888", 29}, { {"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", 231}, { "chapters/dispatch.html", 22} } }, - { {"VUID-vkCmdDispatch-None-08114", 29}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by a bound shader", 176}, { "chapters/dispatch.html", 22} } }, - { {"VUID-vkCmdDispatch-None-08600", 29}, { {"For each set n that is statically used by a bound shader, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 299}, { "chapters/dispatch.html", 22} } }, - { {"VUID-vkCmdDispatch-None-08601", 29}, { {"For each push constant that is statically used by a bound shader, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 315}, { "chapters/dispatch.html", 22} } }, + { {"VUID-vkCmdDispatch-None-08114", 29}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are accessed as described by descriptor validity by a bound shader", 169}, { "chapters/dispatch.html", 22} } }, + { {"VUID-vkCmdDispatch-None-08600", 29}, { {"If a a bound shader statically uses a set n, 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", 286}, { "chapters/dispatch.html", 22} } }, + { {"VUID-vkCmdDispatch-None-08601", 29}, { {"If a a bound shader statically uses a push constant value, that 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", 248}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatch-None-08606", 29}, { {"A valid pipeline must be bound to the pipeline bind point used by this command", 78}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatch-None-08608", 29}, { {"There must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", 213}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatch-None-08609", 29}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's viewType must be VK_IMAGE_VIEW_TYPE_1D or VK_IMAGE_VIEW_TYPE_2D", 215}, { "chapters/dispatch.html", 22} } }, @@ -3950,9 +3973,9 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDispatchBase-None-02693", 33}, { {"If the VK_EXT_filter_cubic extension is not enabled and any VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, it must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY", 255}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchBase-None-07288", 33}, { {"Any shader invocation executed by this command must terminate", 61}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchBase-None-07888", 33}, { {"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", 231}, { "chapters/dispatch.html", 22} } }, - { {"VUID-vkCmdDispatchBase-None-08114", 33}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by a bound shader", 176}, { "chapters/dispatch.html", 22} } }, - { {"VUID-vkCmdDispatchBase-None-08600", 33}, { {"For each set n that is statically used by a bound shader, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 299}, { "chapters/dispatch.html", 22} } }, - { {"VUID-vkCmdDispatchBase-None-08601", 33}, { {"For each push constant that is statically used by a bound shader, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 315}, { "chapters/dispatch.html", 22} } }, + { {"VUID-vkCmdDispatchBase-None-08114", 33}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are accessed as described by descriptor validity by a bound shader", 169}, { "chapters/dispatch.html", 22} } }, + { {"VUID-vkCmdDispatchBase-None-08600", 33}, { {"If a a bound shader statically uses a set n, 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", 286}, { "chapters/dispatch.html", 22} } }, + { {"VUID-vkCmdDispatchBase-None-08601", 33}, { {"If a a bound shader statically uses a push constant value, that 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", 248}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchBase-None-08606", 33}, { {"A valid pipeline must be bound to the pipeline bind point used by this command", 78}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchBase-None-08608", 33}, { {"There must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", 213}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchBase-None-08609", 33}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's viewType must be VK_IMAGE_VIEW_TYPE_1D or VK_IMAGE_VIEW_TYPE_2D", 215}, { "chapters/dispatch.html", 22} } }, @@ -4000,9 +4023,9 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDispatchIndirect-None-02693", 37}, { {"If the VK_EXT_filter_cubic extension is not enabled and any VkImageView is sampled with VK_FILTER_CUBIC_EXT as a result of this command, it must not have a VkImageViewType of VK_IMAGE_VIEW_TYPE_3D, VK_IMAGE_VIEW_TYPE_CUBE, or VK_IMAGE_VIEW_TYPE_CUBE_ARRAY", 255}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchIndirect-None-07288", 37}, { {"Any shader invocation executed by this command must terminate", 61}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchIndirect-None-07888", 37}, { {"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", 231}, { "chapters/dispatch.html", 22} } }, - { {"VUID-vkCmdDispatchIndirect-None-08114", 37}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by a bound shader", 176}, { "chapters/dispatch.html", 22} } }, - { {"VUID-vkCmdDispatchIndirect-None-08600", 37}, { {"For each set n that is statically used by a bound shader, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 299}, { "chapters/dispatch.html", 22} } }, - { {"VUID-vkCmdDispatchIndirect-None-08601", 37}, { {"For each push constant that is statically used by a bound shader, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 315}, { "chapters/dispatch.html", 22} } }, + { {"VUID-vkCmdDispatchIndirect-None-08114", 37}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are accessed as described by descriptor validity by a bound shader", 169}, { "chapters/dispatch.html", 22} } }, + { {"VUID-vkCmdDispatchIndirect-None-08600", 37}, { {"If a a bound shader statically uses a set n, 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", 286}, { "chapters/dispatch.html", 22} } }, + { {"VUID-vkCmdDispatchIndirect-None-08601", 37}, { {"If a a bound shader statically uses a push constant value, that 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", 248}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchIndirect-None-08606", 37}, { {"A valid pipeline must be bound to the pipeline bind point used by this command", 78}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchIndirect-None-08608", 37}, { {"There must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", 213}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchIndirect-None-08609", 37}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's viewType must be VK_IMAGE_VIEW_TYPE_1D or VK_IMAGE_VIEW_TYPE_2D", 215}, { "chapters/dispatch.html", 22} } }, @@ -4019,7 +4042,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDispatchIndirect-SampledType-04473", 44}, { {"If a VkBufferView with a VkFormat that has a component width less than 64-bit is accessed as a result of this command, the SampledType of the OpTypeImage operand of that instruction must have a Width of 32", 205}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchIndirect-aspectMask-06478", 43}, { {"If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT", 147}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchIndirect-buffer-02708", 39}, { {"If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 107}, { "chapters/dispatch.html", 22} } }, - { {"VUID-vkCmdDispatchIndirect-buffer-02709", 39}, { {"buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set", 82}, { "chapters/dispatch.html", 22} } }, + { {"VUID-vkCmdDispatchIndirect-buffer-02709", 39}, { {"buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT usage flag set", 89}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchIndirect-buffer-parameter", 43}, { {"buffer must be a valid VkBuffer handle", 38}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchIndirect-commandBuffer-02707", 46}, { {"If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", 160}, { "chapters/dispatch.html", 22} } }, { {"VUID-vkCmdDispatchIndirect-commandBuffer-02711", 46}, { {"commandBuffer must not be a protected command buffer", 52}, { "chapters/dispatch.html", 22} } }, @@ -4052,18 +4075,16 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDraw-None-04007", 25}, { {"All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have either valid or VK_NULL_HANDLE buffers bound", 170}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-04008", 25}, { {"If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must not be VK_NULL_HANDLE", 188}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-04875", 25}, { {"If the bound graphics pipeline state was created with both a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage and the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled, and the current value of primitiveTopology is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, then vkCmdSetPatchControlPointsEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 410}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-04876", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE dynamic state enabled, then vkCmdSetRasterizerDiscardEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 279}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-04877", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBiasEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 325}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-04879", 25}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 275}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-04876", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE dynamic state enabled, then vkCmdSetRasterizerDiscardEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 276}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-04877", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBiasEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 322}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-04879", 25}, { {"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 and not subsequently invalidated in the current command buffer prior to this drawing command", 272}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-04914", 25}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then vkCmdSetVertexInputEXT must have been called and not subsequently invalidated in the current command buffer prior to this draw command", 253}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-06537", 25}, { {"Memory backing image subresources used as attachments in the current render pass must not be written in any way other than as an attachment by this command", 155}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-06539", 25}, { {"If any previously recorded command in the current subpass accessed an image subresource used as an attachment in this subpass in any way other than as an attachment, this command must not write to that image subresource as an attachment", 236}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-06666", 25}, { {"If the VK_EXT_sample_locations extension is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of sampleLocationsEnable is VK_TRUE, then vkCmdSetSampleLocationsEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 433}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-06886", 25}, { {"If the current render pass instance uses a depth/stencil attachment with a read-only layout for the depth aspect, depth writes must be disabled", 143}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-06887", 25}, { {"If the current render pass instance uses a depth/stencil attachment with a read-only layout for the stencil aspect, both front and back writeMask are not zero, and stencil test is enabled, all stencil ops must be VK_STENCIL_OP_KEEP", 231}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-07288", 25}, { {"Any shader invocation executed by this command must terminate", 61}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-07469", 25}, { {"Input attachment views accessed in a subpass must be created with the same VkFormat as the corresponding subpass definition, and be created with a VkImageView that is compatible with the attachment referenced by the subpass' pInputAttachments[InputAttachmentIndex] in the bound VkFramebuffer as specified by Fragment Input Attachment Compatibility", 347}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-07748", 25}, { {"If any shader statically accesses an input attachment, a valid descriptor must be bound to the pipeline via a descriptor set", 124}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-07831", 25}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled then vkCmdSetViewport must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 242}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-07832", 25}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR dynamic state enabled then vkCmdSetScissor must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 240}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-07834", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthBiasEnable is VK_TRUE, then vkCmdSetDepthBias must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 358}, { "chapters/drawing.html", 21} } }, @@ -4072,19 +4093,19 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDraw-None-07837", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilCompareMask must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 379}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-07838", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilWriteMask must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 375}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-07839", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled, the current value of and rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilReference must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 374}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-07840", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_CULL_MODE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetCullModeEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 310}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-07841", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_FRONT_FACE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetFrontFaceEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 312}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-07842", 25}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 264}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-07843", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, vkCmdSetDepthTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 320}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-07844", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthWriteEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 380}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-07845", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_COMPARE_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthCompareOpEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 372}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-07846", 25}, { {"If the depthBounds feature is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBoundsTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 374}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-07847", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetStencilTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 329}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-07848", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilOpEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 359}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-07840", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_CULL_MODE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetCullMode must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 307}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-07841", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_FRONT_FACE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetFrontFace must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 309}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-07842", 25}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 261}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-07843", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, vkCmdSetDepthTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 317}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-07844", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthWriteEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 377}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-07845", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_COMPARE_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthCompareOp must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 369}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-07846", 25}, { {"If the depthBounds feature is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBoundsTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 371}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-07847", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetStencilTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 326}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-07848", 25}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilOp must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 356}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-07888", 25}, { {"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", 231}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-08114", 25}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by a bound shader", 176}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-08600", 25}, { {"For each set n that is statically used by a bound shader, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 299}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-08601", 25}, { {"For each push constant that is statically used by a bound shader, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 315}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-08114", 25}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are accessed as described by descriptor validity by a bound shader", 169}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-08600", 25}, { {"If a a bound shader statically uses a set n, 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", 286}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-08601", 25}, { {"If a a bound shader statically uses a push constant value, that 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", 248}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-08606", 25}, { {"A valid pipeline must be bound to the pipeline bind point used by this command", 78}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-08608", 25}, { {"There must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", 213}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-08609", 25}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's viewType must be VK_IMAGE_VIEW_TYPE_1D or VK_IMAGE_VIEW_TYPE_2D", 215}, { "chapters/drawing.html", 21} } }, @@ -4095,12 +4116,19 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDraw-None-09203", 25}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then all Input variables at the corresponding Location in the Vertex Execution Model OpEntryPoint must not use components that are not present in the format", 344}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-09462", 25}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, any member of the pVertexBindingDescriptions parameter to the vkCmdSetVertexInputEXT call that sets this dynamic state has a value other than 1 in divisor, and VkPhysicalDeviceVertexAttributeDivisorProperties::supportsNonZeroFirstInstance is VK_FALSE, then firstInstance must be 0", 395}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-09600", 25}, { {"If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", 313}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-09637", 25}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled, then vkCmdSetPrimitiveRestartEnableEXT must be VK_FALSE", 407}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-09637", 25}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled, then vkCmdSetPrimitiveRestartEnable must be VK_FALSE", 404}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-10068", 25}, { {"For each array of resources that is used by a bound shader, the indices used to access members of the array must be less than the descriptor count for the identified binding in the descriptor sets used by this command", 217}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-10795", 25}, { {"If a color attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 211}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-10796", 25}, { {"If a depth attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 211}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-None-10797", 25}, { {"If a stencil attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 213}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-None-10909", 25}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must be VK_FALSE", 233}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-10909", 25}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must be VK_FALSE", 230}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-12338", 25}, { {"If a color attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the color attachment must not be written to by this command", 220}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-12339", 25}, { {"If a depth attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the depth attachment must not be written to by this command", 220}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-None-12340", 25}, { {"If a stencil attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the stencil attachment must not be written to by this command", 224}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-OpExecutionMode-12239", 36}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the type of subdivision, they must be the same", 245}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-OpExecutionMode-12240", 36}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the orientation of triangles, they must be the same", 250}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-OpExecutionMode-12241", 36}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the segment spacing, they must be the same", 241}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-OpExecutionMode-12242", 36}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the output patch size, they must be the same", 243}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-OpImageWrite-04469", 33}, { {"If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view's format", 198}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-OpImageWrite-08795", 33}, { {"If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view's format", 196}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-OpTypeImage-07468", 32}, { {"If any shader executed by this pipeline accesses an OpTypeImage variable with a Dim operand of SubpassData, it must be decorated with an InputAttachmentIndex that corresponds to a valid input attachment in the current subpass", 225}, { "chapters/drawing.html", 21} } }, @@ -4133,15 +4161,15 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDraw-mipmapMode-04770", 31}, { {"If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR, reductionMode equal to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view's format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT", 343}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-mipmapMode-09599", 31}, { {"If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and reductionMode equal to either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX is used to sample a VkImageView as a result of this command, then the image view's format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT", 336}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-pNext-09461", 26}, { {"If the bound graphics pipeline state was created with VkPipelineVertexInputDivisorStateCreateInfo in the pNext chain of VkGraphicsPipelineCreateInfo::pVertexInputState, any member of VkPipelineVertexInputDivisorStateCreateInfo::pVertexBindingDivisors has a value other than 1 in divisor, and VkPhysicalDeviceVertexAttributeDivisorProperties::supportsNonZeroFirstInstance is VK_FALSE, then firstInstance must be 0", 412}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-pStrides-04913", 29}, { {"If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE dynamic state enabled, but without the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called and not subsequently invalidated in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL", 411}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-primitiveFragmentShadingRateWithMultipleViewports-04552", 70}, { {"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 vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1", 487}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-pStrides-04913", 29}, { {"If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE dynamic state enabled, but without the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2 must have been called and not subsequently invalidated in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2 must not be NULL", 405}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-primitiveFragmentShadingRateWithMultipleViewports-04552", 70}, { {"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 vkCmdSetViewportWithCountEXT must be 1", 484}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-primitiveTopology-10286", 38}, { {"If a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage is bound, then the current value of primitiveTopology must be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command", 176}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-primitiveTopology-10747", 38}, { {"If vkCmdSetPrimitiveTopologyEXT set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command, then a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage must be bound", 188}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-primitiveTopology-10748", 38}, { {"If vkCmdSetPrimitiveTopologyEXT set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_POINT_LIST prior to this drawing command, both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT and VK_SHADER_STAGE_GEOMETRY_BIT stage are not bound, then the Vertex Execution Model must have a PointSize decorated variable that is statically written to", 328}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-primitiveTopology-10747", 38}, { {"If vkCmdSetPrimitiveTopology set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command, then a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage must be bound", 185}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-primitiveTopology-10748", 38}, { {"If vkCmdSetPrimitiveTopology set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_POINT_LIST prior to this drawing command, both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT and VK_SHADER_STAGE_GEOMETRY_BIT stage are not bound, then the Vertex Execution Model must have a PointSize decorated variable that is statically written to", 325}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-renderPass-02684", 31}, { {"The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", 195}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-renderpass", 25}, { {"This command must only be called inside of a render pass instance", 65}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-sampleLocationsEnable-02689", 42}, { {"If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE, then the active depth attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set", 261}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-scissorCount-03418", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing", 257}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-scissorCount-03418", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT dynamic state enabled, then vkCmdSetScissorWithCount must have been called and not subsequently invalidated in the current command buffer prior to this drawing", 254}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-sparseImageInt64Atomics-04474", 44}, { {"If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", 250}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-sparseImageInt64Atomics-04475", 44}, { {"If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", 252}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-storageBuffers-06936", 35}, { {"If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, 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", 311}, { "chapters/drawing.html", 21} } }, @@ -4149,7 +4177,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDraw-uniformBuffers-06935", 35}, { {"If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, 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", 311}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-unnormalizedCoordinates-09635", 44}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's levelCount and layerCount must be 1", 187}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-viewType-07752", 29}, { {"If a VkImageView is accessed as a result of this command, then the image view's viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", 223}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDraw-viewportCount-03417", 34}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 267}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDraw-viewportCount-03417", 34}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, then vkCmdSetViewportWithCount must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 264}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDraw-viewportCount-03419", 34}, { {"If a graphics pipeline is bound which was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled, then the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT", 298}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-Input-07939", 33}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then all variables with the Input storage class decorated with Location in the Vertex Execution Model OpEntryPoint must contain a location in VkVertexInputAttributeDescription2EXT::location", 303}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-Input-08734", 33}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then the numeric type associated with all Input variables of the corresponding Location in the Vertex Execution Model OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format", 310}, { "chapters/drawing.html", 21} } }, @@ -4160,19 +4188,17 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexed-None-04007", 32}, { {"All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have either valid or VK_NULL_HANDLE buffers bound", 170}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-04008", 32}, { {"If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must not be VK_NULL_HANDLE", 188}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-04875", 32}, { {"If the bound graphics pipeline state was created with both a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage and the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled, and the current value of primitiveTopology is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, then vkCmdSetPatchControlPointsEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 410}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-04876", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE dynamic state enabled, then vkCmdSetRasterizerDiscardEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 279}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-04877", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBiasEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 325}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-04879", 32}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 275}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-04876", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE dynamic state enabled, then vkCmdSetRasterizerDiscardEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 276}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-04877", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBiasEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 322}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-04879", 32}, { {"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 and not subsequently invalidated in the current command buffer prior to this drawing command", 272}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-04914", 32}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then vkCmdSetVertexInputEXT must have been called and not subsequently invalidated in the current command buffer prior to this draw command", 253}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-06537", 32}, { {"Memory backing image subresources used as attachments in the current render pass must not be written in any way other than as an attachment by this command", 155}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-06539", 32}, { {"If any previously recorded command in the current subpass accessed an image subresource used as an attachment in this subpass in any way other than as an attachment, this command must not write to that image subresource as an attachment", 236}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-06666", 32}, { {"If the VK_EXT_sample_locations extension is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of sampleLocationsEnable is VK_TRUE, then vkCmdSetSampleLocationsEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 433}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-06886", 32}, { {"If the current render pass instance uses a depth/stencil attachment with a read-only layout for the depth aspect, depth writes must be disabled", 143}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-06887", 32}, { {"If the current render pass instance uses a depth/stencil attachment with a read-only layout for the stencil aspect, both front and back writeMask are not zero, and stencil test is enabled, all stencil ops must be VK_STENCIL_OP_KEEP", 231}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-07288", 32}, { {"Any shader invocation executed by this command must terminate", 61}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-07312", 32}, { {"A valid index buffer must be bound", 34}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-07469", 32}, { {"Input attachment views accessed in a subpass must be created with the same VkFormat as the corresponding subpass definition, and be created with a VkImageView that is compatible with the attachment referenced by the subpass' pInputAttachments[InputAttachmentIndex] in the bound VkFramebuffer as specified by Fragment Input Attachment Compatibility", 347}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-07748", 32}, { {"If any shader statically accesses an input attachment, a valid descriptor must be bound to the pipeline via a descriptor set", 124}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-07831", 32}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled then vkCmdSetViewport must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 242}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-07832", 32}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR dynamic state enabled then vkCmdSetScissor must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 240}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-07834", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthBiasEnable is VK_TRUE, then vkCmdSetDepthBias must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 358}, { "chapters/drawing.html", 21} } }, @@ -4181,19 +4207,19 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexed-None-07837", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilCompareMask must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 379}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-07838", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilWriteMask must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 375}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-07839", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled, the current value of and rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilReference must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 374}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-07840", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_CULL_MODE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetCullModeEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 310}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-07841", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_FRONT_FACE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetFrontFaceEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 312}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-07842", 32}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 264}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-07843", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, vkCmdSetDepthTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 320}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-07844", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthWriteEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 380}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-07845", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_COMPARE_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthCompareOpEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 372}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-07846", 32}, { {"If the depthBounds feature is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBoundsTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 374}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-07847", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetStencilTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 329}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-07848", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilOpEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 359}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-07840", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_CULL_MODE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetCullMode must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 307}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-07841", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_FRONT_FACE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetFrontFace must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 309}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-07842", 32}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 261}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-07843", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, vkCmdSetDepthTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 317}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-07844", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthWriteEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 377}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-07845", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_COMPARE_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthCompareOp must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 369}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-07846", 32}, { {"If the depthBounds feature is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBoundsTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 371}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-07847", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetStencilTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 326}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-07848", 32}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilOp must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 356}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-07888", 32}, { {"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", 231}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-08114", 32}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by a bound shader", 176}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-08600", 32}, { {"For each set n that is statically used by a bound shader, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 299}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-08601", 32}, { {"For each push constant that is statically used by a bound shader, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 315}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-08114", 32}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are accessed as described by descriptor validity by a bound shader", 169}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-08600", 32}, { {"If a a bound shader statically uses a set n, 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", 286}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-08601", 32}, { {"If a a bound shader statically uses a push constant value, that 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", 248}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-08606", 32}, { {"A valid pipeline must be bound to the pipeline bind point used by this command", 78}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-08608", 32}, { {"There must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", 213}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-08609", 32}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's viewType must be VK_IMAGE_VIEW_TYPE_1D or VK_IMAGE_VIEW_TYPE_2D", 215}, { "chapters/drawing.html", 21} } }, @@ -4204,12 +4230,19 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexed-None-09203", 32}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then all Input variables at the corresponding Location in the Vertex Execution Model OpEntryPoint must not use components that are not present in the format", 344}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-09462", 32}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, any member of the pVertexBindingDescriptions parameter to the vkCmdSetVertexInputEXT call that sets this dynamic state has a value other than 1 in divisor, and VkPhysicalDeviceVertexAttributeDivisorProperties::supportsNonZeroFirstInstance is VK_FALSE, then firstInstance must be 0", 395}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-09600", 32}, { {"If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", 313}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-09637", 32}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled, then vkCmdSetPrimitiveRestartEnableEXT must be VK_FALSE", 407}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-09637", 32}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled, then vkCmdSetPrimitiveRestartEnable must be VK_FALSE", 404}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-10068", 32}, { {"For each array of resources that is used by a bound shader, the indices used to access members of the array must be less than the descriptor count for the identified binding in the descriptor sets used by this command", 217}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-10795", 32}, { {"If a color attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 211}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-10796", 32}, { {"If a depth attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 211}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-None-10797", 32}, { {"If a stencil attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 213}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-None-10909", 32}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must be VK_FALSE", 233}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-10909", 32}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must be VK_FALSE", 230}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-12338", 32}, { {"If a color attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the color attachment must not be written to by this command", 220}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-12339", 32}, { {"If a depth attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the depth attachment must not be written to by this command", 220}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-None-12340", 32}, { {"If a stencil attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the stencil attachment must not be written to by this command", 224}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-OpExecutionMode-12239", 43}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the type of subdivision, they must be the same", 245}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-OpExecutionMode-12240", 43}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the orientation of triangles, they must be the same", 250}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-OpExecutionMode-12241", 43}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the segment spacing, they must be the same", 241}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-OpExecutionMode-12242", 43}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the output patch size, they must be the same", 243}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-OpImageWrite-04469", 40}, { {"If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view's format", 198}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-OpImageWrite-08795", 40}, { {"If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view's format", 196}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-OpTypeImage-07468", 39}, { {"If any shader executed by this pipeline accesses an OpTypeImage variable with a Dim operand of SubpassData, it must be decorated with an InputAttachmentIndex that corresponds to a valid input attachment in the current subpass", 225}, { "chapters/drawing.html", 21} } }, @@ -4242,16 +4275,16 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexed-mipmapMode-04770", 38}, { {"If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR, reductionMode equal to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view's format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT", 343}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-mipmapMode-09599", 38}, { {"If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and reductionMode equal to either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX is used to sample a VkImageView as a result of this command, then the image view's format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT", 336}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-pNext-09461", 33}, { {"If the bound graphics pipeline state was created with VkPipelineVertexInputDivisorStateCreateInfo in the pNext chain of VkGraphicsPipelineCreateInfo::pVertexInputState, any member of VkPipelineVertexInputDivisorStateCreateInfo::pVertexBindingDivisors has a value other than 1 in divisor, and VkPhysicalDeviceVertexAttributeDivisorProperties::supportsNonZeroFirstInstance is VK_FALSE, then firstInstance must be 0", 412}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-pStrides-04913", 36}, { {"If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE dynamic state enabled, but without the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called and not subsequently invalidated in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL", 411}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-primitiveFragmentShadingRateWithMultipleViewports-04552", 77}, { {"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 vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1", 487}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-pStrides-04913", 36}, { {"If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE dynamic state enabled, but without the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2 must have been called and not subsequently invalidated in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2 must not be NULL", 405}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-primitiveFragmentShadingRateWithMultipleViewports-04552", 77}, { {"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 vkCmdSetViewportWithCountEXT must be 1", 484}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-primitiveTopology-10286", 45}, { {"If a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage is bound, then the current value of primitiveTopology must be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command", 176}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-primitiveTopology-10747", 45}, { {"If vkCmdSetPrimitiveTopologyEXT set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command, then a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage must be bound", 188}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-primitiveTopology-10748", 45}, { {"If vkCmdSetPrimitiveTopologyEXT set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_POINT_LIST prior to this drawing command, both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT and VK_SHADER_STAGE_GEOMETRY_BIT stage are not bound, then the Vertex Execution Model must have a PointSize decorated variable that is statically written to", 328}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-primitiveTopology-10747", 45}, { {"If vkCmdSetPrimitiveTopology set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command, then a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage must be bound", 185}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-primitiveTopology-10748", 45}, { {"If vkCmdSetPrimitiveTopology set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_POINT_LIST prior to this drawing command, both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT and VK_SHADER_STAGE_GEOMETRY_BIT stage are not bound, then the Vertex Execution Model must have a PointSize decorated variable that is statically written to", 325}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-renderPass-02684", 38}, { {"The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", 195}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-renderpass", 32}, { {"This command must only be called inside of a render pass instance", 65}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-robustBufferAccess2-08798", 47}, { {"If the robustBufferAccess2 feature is not enabled, (indexSize x (firstIndex + indexCount) + offset) must be less than or equal to the size of the bound index buffer, with indexSize being based on the type specified by indexType, where the index buffer, indexType, and offset are specified via vkCmdBindIndexBuffer", 313}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-sampleLocationsEnable-02689", 49}, { {"If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE, then the active depth attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set", 261}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-scissorCount-03418", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing", 257}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-scissorCount-03418", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT dynamic state enabled, then vkCmdSetScissorWithCount must have been called and not subsequently invalidated in the current command buffer prior to this drawing", 254}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-sparseImageInt64Atomics-04474", 51}, { {"If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", 250}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-sparseImageInt64Atomics-04475", 51}, { {"If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", 252}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-storageBuffers-06936", 42}, { {"If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, 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", 311}, { "chapters/drawing.html", 21} } }, @@ -4259,7 +4292,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexed-uniformBuffers-06935", 42}, { {"If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, 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", 311}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-unnormalizedCoordinates-09635", 51}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's levelCount and layerCount must be 1", 187}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-viewType-07752", 36}, { {"If a VkImageView is accessed as a result of this command, then the image view's viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", 223}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexed-viewportCount-03417", 41}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 267}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexed-viewportCount-03417", 41}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, then vkCmdSetViewportWithCount must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 264}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexed-viewportCount-03419", 41}, { {"If a graphics pipeline is bound which was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled, then the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT", 298}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-Input-07939", 41}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then all variables with the Input storage class decorated with Location in the Vertex Execution Model OpEntryPoint must contain a location in VkVertexInputAttributeDescription2EXT::location", 303}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-Input-08734", 41}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then the numeric type associated with all Input variables of the corresponding Location in the Vertex Execution Model OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format", 310}, { "chapters/drawing.html", 21} } }, @@ -4270,19 +4303,17 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexedIndirect-None-04007", 40}, { {"All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have either valid or VK_NULL_HANDLE buffers bound", 170}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-04008", 40}, { {"If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must not be VK_NULL_HANDLE", 188}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-04875", 40}, { {"If the bound graphics pipeline state was created with both a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage and the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled, and the current value of primitiveTopology is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, then vkCmdSetPatchControlPointsEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 410}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-04876", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE dynamic state enabled, then vkCmdSetRasterizerDiscardEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 279}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-04877", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBiasEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 325}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-04879", 40}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 275}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-04876", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE dynamic state enabled, then vkCmdSetRasterizerDiscardEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 276}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-04877", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBiasEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 322}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-04879", 40}, { {"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 and not subsequently invalidated in the current command buffer prior to this drawing command", 272}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-04914", 40}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then vkCmdSetVertexInputEXT must have been called and not subsequently invalidated in the current command buffer prior to this draw command", 253}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-06537", 40}, { {"Memory backing image subresources used as attachments in the current render pass must not be written in any way other than as an attachment by this command", 155}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-06539", 40}, { {"If any previously recorded command in the current subpass accessed an image subresource used as an attachment in this subpass in any way other than as an attachment, this command must not write to that image subresource as an attachment", 236}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-06666", 40}, { {"If the VK_EXT_sample_locations extension is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of sampleLocationsEnable is VK_TRUE, then vkCmdSetSampleLocationsEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 433}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-06886", 40}, { {"If the current render pass instance uses a depth/stencil attachment with a read-only layout for the depth aspect, depth writes must be disabled", 143}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-06887", 40}, { {"If the current render pass instance uses a depth/stencil attachment with a read-only layout for the stencil aspect, both front and back writeMask are not zero, and stencil test is enabled, all stencil ops must be VK_STENCIL_OP_KEEP", 231}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-07288", 40}, { {"Any shader invocation executed by this command must terminate", 61}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-07312", 40}, { {"A valid index buffer must be bound", 34}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-07469", 40}, { {"Input attachment views accessed in a subpass must be created with the same VkFormat as the corresponding subpass definition, and be created with a VkImageView that is compatible with the attachment referenced by the subpass' pInputAttachments[InputAttachmentIndex] in the bound VkFramebuffer as specified by Fragment Input Attachment Compatibility", 347}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-07748", 40}, { {"If any shader statically accesses an input attachment, a valid descriptor must be bound to the pipeline via a descriptor set", 124}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-07831", 40}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled then vkCmdSetViewport must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 242}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-07832", 40}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR dynamic state enabled then vkCmdSetScissor must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 240}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-07834", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthBiasEnable is VK_TRUE, then vkCmdSetDepthBias must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 358}, { "chapters/drawing.html", 21} } }, @@ -4291,19 +4322,19 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexedIndirect-None-07837", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilCompareMask must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 379}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-07838", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilWriteMask must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 375}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-07839", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled, the current value of and rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilReference must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 374}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-07840", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_CULL_MODE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetCullModeEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 310}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-07841", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_FRONT_FACE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetFrontFaceEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 312}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-07842", 40}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 264}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-07843", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, vkCmdSetDepthTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 320}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-07844", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthWriteEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 380}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-07845", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_COMPARE_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthCompareOpEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 372}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-07846", 40}, { {"If the depthBounds feature is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBoundsTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 374}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-07847", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetStencilTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 329}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-07848", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilOpEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 359}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-07840", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_CULL_MODE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetCullMode must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 307}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-07841", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_FRONT_FACE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetFrontFace must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 309}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-07842", 40}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 261}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-07843", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, vkCmdSetDepthTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 317}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-07844", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthWriteEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 377}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-07845", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_COMPARE_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthCompareOp must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 369}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-07846", 40}, { {"If the depthBounds feature is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBoundsTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 371}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-07847", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetStencilTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 326}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-07848", 40}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilOp must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 356}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-07888", 40}, { {"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", 231}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-08114", 40}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by a bound shader", 176}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-08600", 40}, { {"For each set n that is statically used by a bound shader, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 299}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-08601", 40}, { {"For each push constant that is statically used by a bound shader, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 315}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-08114", 40}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are accessed as described by descriptor validity by a bound shader", 169}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-08600", 40}, { {"If a a bound shader statically uses a set n, 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", 286}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-08601", 40}, { {"If a a bound shader statically uses a push constant value, that 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", 248}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-08606", 40}, { {"A valid pipeline must be bound to the pipeline bind point used by this command", 78}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-08608", 40}, { {"There must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", 213}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-08609", 40}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's viewType must be VK_IMAGE_VIEW_TYPE_1D or VK_IMAGE_VIEW_TYPE_2D", 215}, { "chapters/drawing.html", 21} } }, @@ -4313,12 +4344,19 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexedIndirect-None-08644", 40}, { {"If a graphics pipeline is bound, the current value of rasterizerDiscardEnable is VK_FALSE, then the current value of rasterizationSamples must be the same as the current color and/or depth/stencil attachments", 208}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-09203", 40}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then all Input variables at the corresponding Location in the Vertex Execution Model OpEntryPoint must not use components that are not present in the format", 344}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-09600", 40}, { {"If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", 313}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-09637", 40}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled, then vkCmdSetPrimitiveRestartEnableEXT must be VK_FALSE", 407}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-09637", 40}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled, then vkCmdSetPrimitiveRestartEnable must be VK_FALSE", 404}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-10068", 40}, { {"For each array of resources that is used by a bound shader, the indices used to access members of the array must be less than the descriptor count for the identified binding in the descriptor sets used by this command", 217}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-10795", 40}, { {"If a color attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 211}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-10796", 40}, { {"If a depth attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 211}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-None-10797", 40}, { {"If a stencil attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 213}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-None-10909", 40}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must be VK_FALSE", 233}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-10909", 40}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must be VK_FALSE", 230}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-12338", 40}, { {"If a color attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the color attachment must not be written to by this command", 220}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-12339", 40}, { {"If a depth attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the depth attachment must not be written to by this command", 220}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-None-12340", 40}, { {"If a stencil attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the stencil attachment must not be written to by this command", 224}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-OpExecutionMode-12239", 51}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the type of subdivision, they must be the same", 245}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-OpExecutionMode-12240", 51}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the orientation of triangles, they must be the same", 250}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-OpExecutionMode-12241", 51}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the segment spacing, they must be the same", 241}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-OpExecutionMode-12242", 51}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the output patch size, they must be the same", 243}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-OpImageWrite-04469", 48}, { {"If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view's format", 198}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-OpImageWrite-08795", 48}, { {"If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view's format", 196}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-OpTypeImage-07468", 47}, { {"If any shader executed by this pipeline accesses an OpTypeImage variable with a Dim operand of SubpassData, it must be decorated with an InputAttachmentIndex that corresponds to a valid input attachment in the current subpass", 225}, { "chapters/drawing.html", 21} } }, @@ -4329,7 +4367,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexedIndirect-aspectMask-06478", 46}, { {"If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT", 147}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-blendEnable-04727", 47}, { {"If a graphics pipeline is bound which was created with VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, then for each color attachment, if the corresponding image view's format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding current value of blendEnable must be VK_FALSE", 387}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-buffer-02708", 42}, { {"If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 107}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-buffer-02709", 42}, { {"buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set", 82}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-buffer-02709", 42}, { {"buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT usage flag set", 89}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-buffer-parameter", 46}, { {"buffer must be a valid VkBuffer handle", 38}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-commandBuffer-02707", 49}, { {"If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", 160}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-commandBuffer-02711", 49}, { {"commandBuffer must not be a protected command buffer", 52}, { "chapters/drawing.html", 21} } }, @@ -4359,15 +4397,15 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexedIndirect-mipmapMode-04770", 46}, { {"If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR, reductionMode equal to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view's format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT", 343}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-mipmapMode-09599", 46}, { {"If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and reductionMode equal to either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX is used to sample a VkImageView as a result of this command, then the image view's format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT", 336}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-offset-02710", 42}, { {"offset must be a multiple of 4", 30}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-pStrides-04913", 44}, { {"If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE dynamic state enabled, but without the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called and not subsequently invalidated in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL", 411}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-primitiveFragmentShadingRateWithMultipleViewports-04552", 85}, { {"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 vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1", 487}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-pStrides-04913", 44}, { {"If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE dynamic state enabled, but without the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2 must have been called and not subsequently invalidated in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2 must not be NULL", 405}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-primitiveFragmentShadingRateWithMultipleViewports-04552", 85}, { {"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 vkCmdSetViewportWithCountEXT must be 1", 484}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-primitiveTopology-10286", 53}, { {"If a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage is bound, then the current value of primitiveTopology must be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command", 176}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-primitiveTopology-10747", 53}, { {"If vkCmdSetPrimitiveTopologyEXT set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command, then a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage must be bound", 188}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-primitiveTopology-10748", 53}, { {"If vkCmdSetPrimitiveTopologyEXT set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_POINT_LIST prior to this drawing command, both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT and VK_SHADER_STAGE_GEOMETRY_BIT stage are not bound, then the Vertex Execution Model must have a PointSize decorated variable that is statically written to", 328}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-primitiveTopology-10747", 53}, { {"If vkCmdSetPrimitiveTopology set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command, then a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage must be bound", 185}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-primitiveTopology-10748", 53}, { {"If vkCmdSetPrimitiveTopology set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_POINT_LIST prior to this drawing command, both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT and VK_SHADER_STAGE_GEOMETRY_BIT stage are not bound, then the Vertex Execution Model must have a PointSize decorated variable that is statically written to", 325}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-renderPass-02684", 46}, { {"The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", 195}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-renderpass", 40}, { {"This command must only be called inside of a render pass instance", 65}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-sampleLocationsEnable-02689", 57}, { {"If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE, then the active depth attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set", 261}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-scissorCount-03418", 48}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing", 257}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-scissorCount-03418", 48}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT dynamic state enabled, then vkCmdSetScissorWithCount must have been called and not subsequently invalidated in the current command buffer prior to this drawing", 254}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-sparseImageInt64Atomics-04474", 59}, { {"If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", 250}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-sparseImageInt64Atomics-04475", 59}, { {"If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", 252}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-storageBuffers-06936", 50}, { {"If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, 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", 311}, { "chapters/drawing.html", 21} } }, @@ -4375,7 +4413,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexedIndirect-uniformBuffers-06935", 50}, { {"If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, 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", 311}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-unnormalizedCoordinates-09635", 59}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's levelCount and layerCount must be 1", 187}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-viewType-07752", 44}, { {"If a VkImageView is accessed as a result of this command, then the image view's viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", 223}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirect-viewportCount-03417", 49}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 267}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirect-viewportCount-03417", 49}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, then vkCmdSetViewportWithCount must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 264}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirect-viewportCount-03419", 49}, { {"If a graphics pipeline is bound which was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled, then the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT", 298}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-Input-07939", 46}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then all variables with the Input storage class decorated with Location in the Vertex Execution Model OpEntryPoint must contain a location in VkVertexInputAttributeDescription2EXT::location", 303}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-Input-08734", 46}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then the numeric type associated with all Input variables of the corresponding Location in the Vertex Execution Model OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format", 310}, { "chapters/drawing.html", 21} } }, @@ -4387,19 +4425,17 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexedIndirectCount-None-04008", 45}, { {"If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must not be VK_NULL_HANDLE", 188}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-04445", 45}, { {"If the drawIndirectCount feature is not enabled this function must not be used", 78}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-04875", 45}, { {"If the bound graphics pipeline state was created with both a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage and the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled, and the current value of primitiveTopology is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, then vkCmdSetPatchControlPointsEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 410}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-04876", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE dynamic state enabled, then vkCmdSetRasterizerDiscardEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 279}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-04877", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBiasEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 325}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-04879", 45}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 275}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-04876", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE dynamic state enabled, then vkCmdSetRasterizerDiscardEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 276}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-04877", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBiasEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 322}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-04879", 45}, { {"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 and not subsequently invalidated in the current command buffer prior to this drawing command", 272}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-04914", 45}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then vkCmdSetVertexInputEXT must have been called and not subsequently invalidated in the current command buffer prior to this draw command", 253}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-06537", 45}, { {"Memory backing image subresources used as attachments in the current render pass must not be written in any way other than as an attachment by this command", 155}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-06539", 45}, { {"If any previously recorded command in the current subpass accessed an image subresource used as an attachment in this subpass in any way other than as an attachment, this command must not write to that image subresource as an attachment", 236}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-06666", 45}, { {"If the VK_EXT_sample_locations extension is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of sampleLocationsEnable is VK_TRUE, then vkCmdSetSampleLocationsEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 433}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-06886", 45}, { {"If the current render pass instance uses a depth/stencil attachment with a read-only layout for the depth aspect, depth writes must be disabled", 143}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-06887", 45}, { {"If the current render pass instance uses a depth/stencil attachment with a read-only layout for the stencil aspect, both front and back writeMask are not zero, and stencil test is enabled, all stencil ops must be VK_STENCIL_OP_KEEP", 231}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-07288", 45}, { {"Any shader invocation executed by this command must terminate", 61}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-07312", 45}, { {"A valid index buffer must be bound", 34}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-07469", 45}, { {"Input attachment views accessed in a subpass must be created with the same VkFormat as the corresponding subpass definition, and be created with a VkImageView that is compatible with the attachment referenced by the subpass' pInputAttachments[InputAttachmentIndex] in the bound VkFramebuffer as specified by Fragment Input Attachment Compatibility", 347}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-07748", 45}, { {"If any shader statically accesses an input attachment, a valid descriptor must be bound to the pipeline via a descriptor set", 124}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-07831", 45}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled then vkCmdSetViewport must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 242}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-07832", 45}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR dynamic state enabled then vkCmdSetScissor must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 240}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-07834", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthBiasEnable is VK_TRUE, then vkCmdSetDepthBias must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 358}, { "chapters/drawing.html", 21} } }, @@ -4408,19 +4444,19 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexedIndirectCount-None-07837", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilCompareMask must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 379}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-07838", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilWriteMask must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 375}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-07839", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled, the current value of and rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilReference must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 374}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-07840", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_CULL_MODE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetCullModeEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 310}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-07841", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_FRONT_FACE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetFrontFaceEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 312}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-07842", 45}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 264}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-07843", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, vkCmdSetDepthTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 320}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-07844", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthWriteEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 380}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-07845", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_COMPARE_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthCompareOpEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 372}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-07846", 45}, { {"If the depthBounds feature is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBoundsTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 374}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-07847", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetStencilTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 329}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-07848", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilOpEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 359}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-07840", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_CULL_MODE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetCullMode must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 307}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-07841", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_FRONT_FACE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetFrontFace must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 309}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-07842", 45}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 261}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-07843", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, vkCmdSetDepthTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 317}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-07844", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthWriteEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 377}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-07845", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_COMPARE_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthCompareOp must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 369}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-07846", 45}, { {"If the depthBounds feature is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBoundsTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 371}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-07847", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetStencilTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 326}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-07848", 45}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilOp must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 356}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-07888", 45}, { {"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", 231}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-08114", 45}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by a bound shader", 176}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-08600", 45}, { {"For each set n that is statically used by a bound shader, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 299}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-08601", 45}, { {"For each push constant that is statically used by a bound shader, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 315}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-08114", 45}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are accessed as described by descriptor validity by a bound shader", 169}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-08600", 45}, { {"If a a bound shader statically uses a set n, 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", 286}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-08601", 45}, { {"If a a bound shader statically uses a push constant value, that 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", 248}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-08606", 45}, { {"A valid pipeline must be bound to the pipeline bind point used by this command", 78}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-08608", 45}, { {"There must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", 213}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-08609", 45}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's viewType must be VK_IMAGE_VIEW_TYPE_1D or VK_IMAGE_VIEW_TYPE_2D", 215}, { "chapters/drawing.html", 21} } }, @@ -4430,12 +4466,19 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexedIndirectCount-None-08644", 45}, { {"If a graphics pipeline is bound, the current value of rasterizerDiscardEnable is VK_FALSE, then the current value of rasterizationSamples must be the same as the current color and/or depth/stencil attachments", 208}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-09203", 45}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then all Input variables at the corresponding Location in the Vertex Execution Model OpEntryPoint must not use components that are not present in the format", 344}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-09600", 45}, { {"If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", 313}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-09637", 45}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled, then vkCmdSetPrimitiveRestartEnableEXT must be VK_FALSE", 407}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-09637", 45}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled, then vkCmdSetPrimitiveRestartEnable must be VK_FALSE", 404}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-10068", 45}, { {"For each array of resources that is used by a bound shader, the indices used to access members of the array must be less than the descriptor count for the identified binding in the descriptor sets used by this command", 217}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-10795", 45}, { {"If a color attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 211}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-10796", 45}, { {"If a depth attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 211}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-None-10797", 45}, { {"If a stencil attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 213}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-None-10909", 45}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must be VK_FALSE", 233}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-10909", 45}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must be VK_FALSE", 230}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-12338", 45}, { {"If a color attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the color attachment must not be written to by this command", 220}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-12339", 45}, { {"If a depth attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the depth attachment must not be written to by this command", 220}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-None-12340", 45}, { {"If a stencil attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the stencil attachment must not be written to by this command", 224}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-OpExecutionMode-12239", 56}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the type of subdivision, they must be the same", 245}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-OpExecutionMode-12240", 56}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the orientation of triangles, they must be the same", 250}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-OpExecutionMode-12241", 56}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the segment spacing, they must be the same", 241}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-OpExecutionMode-12242", 56}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the output patch size, they must be the same", 243}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-OpImageWrite-04469", 53}, { {"If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view's format", 198}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-OpImageWrite-08795", 53}, { {"If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view's format", 196}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-OpTypeImage-07468", 52}, { {"If any shader executed by this pipeline accesses an OpTypeImage variable with a Dim operand of SubpassData, it must be decorated with an InputAttachmentIndex that corresponds to a valid input attachment in the current subpass", 225}, { "chapters/drawing.html", 21} } }, @@ -4446,7 +4489,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexedIndirectCount-aspectMask-06478", 51}, { {"If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT", 147}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-blendEnable-04727", 52}, { {"If a graphics pipeline is bound which was created with VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, then for each color attachment, if the corresponding image view's format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding current value of blendEnable must be VK_FALSE", 387}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-buffer-02708", 47}, { {"If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 107}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-buffer-02709", 47}, { {"buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set", 82}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-buffer-02709", 47}, { {"buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT usage flag set", 89}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-buffer-parameter", 51}, { {"buffer must be a valid VkBuffer handle", 38}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02707", 54}, { {"If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", 160}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-02711", 54}, { {"commandBuffer must not be a protected command buffer", 52}, { "chapters/drawing.html", 21} } }, @@ -4455,7 +4498,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexedIndirectCount-commandBuffer-recording", 58}, { {"commandBuffer must be in the recording state", 44}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-commonparent", 47}, { {"Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice", 117}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02714", 52}, { {"If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 112}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02715", 52}, { {"countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set", 87}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02715", 52}, { {"countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT usage flag set", 94}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-countBuffer-02717", 52}, { {"The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount", 106}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-countBuffer-parameter", 56}, { {"countBuffer must be a valid VkBuffer handle", 43}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-countBufferOffset-02716", 58}, { {"countBufferOffset must be a multiple of 4", 41}, { "chapters/drawing.html", 21} } }, @@ -4478,15 +4521,15 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexedIndirectCount-mipmapMode-04770", 51}, { {"If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR, reductionMode equal to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view's format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT", 343}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-mipmapMode-09599", 51}, { {"If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and reductionMode equal to either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX is used to sample a VkImageView as a result of this command, then the image view's format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT", 336}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-offset-02710", 47}, { {"offset must be a multiple of 4", 30}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-pStrides-04913", 49}, { {"If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE dynamic state enabled, but without the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called and not subsequently invalidated in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL", 411}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-primitiveFragmentShadingRateWithMultipleViewports-04552", 90}, { {"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 vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1", 487}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-pStrides-04913", 49}, { {"If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE dynamic state enabled, but without the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2 must have been called and not subsequently invalidated in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2 must not be NULL", 405}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-primitiveFragmentShadingRateWithMultipleViewports-04552", 90}, { {"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 vkCmdSetViewportWithCountEXT must be 1", 484}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-primitiveTopology-10286", 58}, { {"If a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage is bound, then the current value of primitiveTopology must be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command", 176}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-primitiveTopology-10747", 58}, { {"If vkCmdSetPrimitiveTopologyEXT set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command, then a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage must be bound", 188}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-primitiveTopology-10748", 58}, { {"If vkCmdSetPrimitiveTopologyEXT set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_POINT_LIST prior to this drawing command, both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT and VK_SHADER_STAGE_GEOMETRY_BIT stage are not bound, then the Vertex Execution Model must have a PointSize decorated variable that is statically written to", 328}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-primitiveTopology-10747", 58}, { {"If vkCmdSetPrimitiveTopology set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command, then a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage must be bound", 185}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-primitiveTopology-10748", 58}, { {"If vkCmdSetPrimitiveTopology set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_POINT_LIST prior to this drawing command, both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT and VK_SHADER_STAGE_GEOMETRY_BIT stage are not bound, then the Vertex Execution Model must have a PointSize decorated variable that is statically written to", 325}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-renderPass-02684", 51}, { {"The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", 195}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-renderpass", 45}, { {"This command must only be called inside of a render pass instance", 65}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-sampleLocationsEnable-02689", 62}, { {"If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE, then the active depth attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set", 261}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-scissorCount-03418", 53}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing", 257}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-scissorCount-03418", 53}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT dynamic state enabled, then vkCmdSetScissorWithCount must have been called and not subsequently invalidated in the current command buffer prior to this drawing", 254}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-sparseImageInt64Atomics-04474", 64}, { {"If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", 250}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-sparseImageInt64Atomics-04475", 64}, { {"If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", 252}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-storageBuffers-06936", 55}, { {"If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, 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", 311}, { "chapters/drawing.html", 21} } }, @@ -4495,7 +4538,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndexedIndirectCount-uniformBuffers-06935", 55}, { {"If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, 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", 311}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-unnormalizedCoordinates-09635", 64}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's levelCount and layerCount must be 1", 187}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-viewType-07752", 49}, { {"If a VkImageView is accessed as a result of this command, then the image view's viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", 223}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndexedIndirectCount-viewportCount-03417", 54}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 267}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndexedIndirectCount-viewportCount-03417", 54}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, then vkCmdSetViewportWithCount must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 264}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndexedIndirectCount-viewportCount-03419", 54}, { {"If a graphics pipeline is bound which was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled, then the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT", 298}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-Input-07939", 34}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then all variables with the Input storage class decorated with Location in the Vertex Execution Model OpEntryPoint must contain a location in VkVertexInputAttributeDescription2EXT::location", 303}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-Input-08734", 34}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then the numeric type associated with all Input variables of the corresponding Location in the Vertex Execution Model OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format", 310}, { "chapters/drawing.html", 21} } }, @@ -4506,18 +4549,16 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndirect-None-04007", 33}, { {"All vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must have either valid or VK_NULL_HANDLE buffers bound", 170}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-04008", 33}, { {"If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must not be VK_NULL_HANDLE", 188}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-04875", 33}, { {"If the bound graphics pipeline state was created with both a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage and the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled, and the current value of primitiveTopology is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, then vkCmdSetPatchControlPointsEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 410}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-04876", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE dynamic state enabled, then vkCmdSetRasterizerDiscardEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 279}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-04877", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBiasEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 325}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-04879", 33}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 275}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-04876", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE dynamic state enabled, then vkCmdSetRasterizerDiscardEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 276}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-04877", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBiasEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 322}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-04879", 33}, { {"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 and not subsequently invalidated in the current command buffer prior to this drawing command", 272}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-04914", 33}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then vkCmdSetVertexInputEXT must have been called and not subsequently invalidated in the current command buffer prior to this draw command", 253}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-06537", 33}, { {"Memory backing image subresources used as attachments in the current render pass must not be written in any way other than as an attachment by this command", 155}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-06539", 33}, { {"If any previously recorded command in the current subpass accessed an image subresource used as an attachment in this subpass in any way other than as an attachment, this command must not write to that image subresource as an attachment", 236}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-06666", 33}, { {"If the VK_EXT_sample_locations extension is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of sampleLocationsEnable is VK_TRUE, then vkCmdSetSampleLocationsEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 433}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-06886", 33}, { {"If the current render pass instance uses a depth/stencil attachment with a read-only layout for the depth aspect, depth writes must be disabled", 143}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-06887", 33}, { {"If the current render pass instance uses a depth/stencil attachment with a read-only layout for the stencil aspect, both front and back writeMask are not zero, and stencil test is enabled, all stencil ops must be VK_STENCIL_OP_KEEP", 231}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-07288", 33}, { {"Any shader invocation executed by this command must terminate", 61}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-07469", 33}, { {"Input attachment views accessed in a subpass must be created with the same VkFormat as the corresponding subpass definition, and be created with a VkImageView that is compatible with the attachment referenced by the subpass' pInputAttachments[InputAttachmentIndex] in the bound VkFramebuffer as specified by Fragment Input Attachment Compatibility", 347}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-07748", 33}, { {"If any shader statically accesses an input attachment, a valid descriptor must be bound to the pipeline via a descriptor set", 124}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-07831", 33}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled then vkCmdSetViewport must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 242}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-07832", 33}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR dynamic state enabled then vkCmdSetScissor must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 240}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-07834", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthBiasEnable is VK_TRUE, then vkCmdSetDepthBias must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 358}, { "chapters/drawing.html", 21} } }, @@ -4526,19 +4567,19 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndirect-None-07837", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilCompareMask must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 379}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-07838", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilWriteMask must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 375}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-07839", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled, the current value of and rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilReference must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 374}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-07840", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_CULL_MODE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetCullModeEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 310}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-07841", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_FRONT_FACE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetFrontFaceEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 312}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-07842", 33}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 264}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-07843", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, vkCmdSetDepthTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 320}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-07844", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthWriteEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 380}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-07845", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_COMPARE_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthCompareOpEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 372}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-07846", 33}, { {"If the depthBounds feature is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBoundsTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 374}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-07847", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetStencilTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 329}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-07848", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilOpEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 359}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-07840", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_CULL_MODE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetCullMode must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 307}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-07841", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_FRONT_FACE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetFrontFace must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 309}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-07842", 33}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 261}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-07843", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, vkCmdSetDepthTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 317}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-07844", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthWriteEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 377}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-07845", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_COMPARE_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthCompareOp must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 369}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-07846", 33}, { {"If the depthBounds feature is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBoundsTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 371}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-07847", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetStencilTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 326}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-07848", 33}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilOp must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 356}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-07888", 33}, { {"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", 231}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-08114", 33}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by a bound shader", 176}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-08600", 33}, { {"For each set n that is statically used by a bound shader, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 299}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-08601", 33}, { {"For each push constant that is statically used by a bound shader, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 315}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-08114", 33}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are accessed as described by descriptor validity by a bound shader", 169}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-08600", 33}, { {"If a a bound shader statically uses a set n, 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", 286}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-08601", 33}, { {"If a a bound shader statically uses a push constant value, that 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", 248}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-08606", 33}, { {"A valid pipeline must be bound to the pipeline bind point used by this command", 78}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-08608", 33}, { {"There must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", 213}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-08609", 33}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's viewType must be VK_IMAGE_VIEW_TYPE_1D or VK_IMAGE_VIEW_TYPE_2D", 215}, { "chapters/drawing.html", 21} } }, @@ -4548,12 +4589,19 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndirect-None-08644", 33}, { {"If a graphics pipeline is bound, the current value of rasterizerDiscardEnable is VK_FALSE, then the current value of rasterizationSamples must be the same as the current color and/or depth/stencil attachments", 208}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-09203", 33}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then all Input variables at the corresponding Location in the Vertex Execution Model OpEntryPoint must not use components that are not present in the format", 344}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-09600", 33}, { {"If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", 313}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-09637", 33}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled, then vkCmdSetPrimitiveRestartEnableEXT must be VK_FALSE", 407}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-09637", 33}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled, then vkCmdSetPrimitiveRestartEnable must be VK_FALSE", 404}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-10068", 33}, { {"For each array of resources that is used by a bound shader, the indices used to access members of the array must be less than the descriptor count for the identified binding in the descriptor sets used by this command", 217}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-10795", 33}, { {"If a color attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 211}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-10796", 33}, { {"If a depth attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 211}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-None-10797", 33}, { {"If a stencil attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 213}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-None-10909", 33}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must be VK_FALSE", 233}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-10909", 33}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must be VK_FALSE", 230}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-12338", 33}, { {"If a color attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the color attachment must not be written to by this command", 220}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-12339", 33}, { {"If a depth attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the depth attachment must not be written to by this command", 220}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-None-12340", 33}, { {"If a stencil attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the stencil attachment must not be written to by this command", 224}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-OpExecutionMode-12239", 44}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the type of subdivision, they must be the same", 245}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-OpExecutionMode-12240", 44}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the orientation of triangles, they must be the same", 250}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-OpExecutionMode-12241", 44}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the segment spacing, they must be the same", 241}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-OpExecutionMode-12242", 44}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the output patch size, they must be the same", 243}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-OpImageWrite-04469", 41}, { {"If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view's format", 198}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-OpImageWrite-08795", 41}, { {"If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view's format", 196}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-OpTypeImage-07468", 40}, { {"If any shader executed by this pipeline accesses an OpTypeImage variable with a Dim operand of SubpassData, it must be decorated with an InputAttachmentIndex that corresponds to a valid input attachment in the current subpass", 225}, { "chapters/drawing.html", 21} } }, @@ -4564,7 +4612,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndirect-aspectMask-06478", 39}, { {"If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT", 147}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-blendEnable-04727", 40}, { {"If a graphics pipeline is bound which was created with VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, then for each color attachment, if the corresponding image view's format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding current value of blendEnable must be VK_FALSE", 387}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-buffer-02708", 35}, { {"If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 107}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-buffer-02709", 35}, { {"buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set", 82}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-buffer-02709", 35}, { {"buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT usage flag set", 89}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-buffer-parameter", 39}, { {"buffer must be a valid VkBuffer handle", 38}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-commandBuffer-02707", 42}, { {"If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", 160}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-commandBuffer-02711", 42}, { {"commandBuffer must not be a protected command buffer", 52}, { "chapters/drawing.html", 21} } }, @@ -4594,15 +4642,15 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndirect-mipmapMode-04770", 39}, { {"If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR, reductionMode equal to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view's format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT", 343}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-mipmapMode-09599", 39}, { {"If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and reductionMode equal to either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX is used to sample a VkImageView as a result of this command, then the image view's format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT", 336}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-offset-02710", 35}, { {"offset must be a multiple of 4", 30}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-pStrides-04913", 37}, { {"If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE dynamic state enabled, but without the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called and not subsequently invalidated in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL", 411}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-primitiveFragmentShadingRateWithMultipleViewports-04552", 78}, { {"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 vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1", 487}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-pStrides-04913", 37}, { {"If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE dynamic state enabled, but without the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2 must have been called and not subsequently invalidated in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2 must not be NULL", 405}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-primitiveFragmentShadingRateWithMultipleViewports-04552", 78}, { {"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 vkCmdSetViewportWithCountEXT must be 1", 484}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-primitiveTopology-10286", 46}, { {"If a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage is bound, then the current value of primitiveTopology must be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command", 176}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-primitiveTopology-10747", 46}, { {"If vkCmdSetPrimitiveTopologyEXT set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command, then a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage must be bound", 188}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-primitiveTopology-10748", 46}, { {"If vkCmdSetPrimitiveTopologyEXT set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_POINT_LIST prior to this drawing command, both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT and VK_SHADER_STAGE_GEOMETRY_BIT stage are not bound, then the Vertex Execution Model must have a PointSize decorated variable that is statically written to", 328}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-primitiveTopology-10747", 46}, { {"If vkCmdSetPrimitiveTopology set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command, then a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage must be bound", 185}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-primitiveTopology-10748", 46}, { {"If vkCmdSetPrimitiveTopology set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_POINT_LIST prior to this drawing command, both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT and VK_SHADER_STAGE_GEOMETRY_BIT stage are not bound, then the Vertex Execution Model must have a PointSize decorated variable that is statically written to", 325}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-renderPass-02684", 39}, { {"The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", 195}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-renderpass", 33}, { {"This command must only be called inside of a render pass instance", 65}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-sampleLocationsEnable-02689", 50}, { {"If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE, then the active depth attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set", 261}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-scissorCount-03418", 41}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing", 257}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-scissorCount-03418", 41}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT dynamic state enabled, then vkCmdSetScissorWithCount must have been called and not subsequently invalidated in the current command buffer prior to this drawing", 254}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-sparseImageInt64Atomics-04474", 52}, { {"If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", 250}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-sparseImageInt64Atomics-04475", 52}, { {"If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", 252}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-storageBuffers-06936", 43}, { {"If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, 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", 311}, { "chapters/drawing.html", 21} } }, @@ -4610,7 +4658,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndirect-uniformBuffers-06935", 43}, { {"If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, 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", 311}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-unnormalizedCoordinates-09635", 52}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's levelCount and layerCount must be 1", 187}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-viewType-07752", 37}, { {"If a VkImageView is accessed as a result of this command, then the image view's viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", 223}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirect-viewportCount-03417", 42}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 267}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirect-viewportCount-03417", 42}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, then vkCmdSetViewportWithCount must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 264}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirect-viewportCount-03419", 42}, { {"If a graphics pipeline is bound which was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled, then the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT", 298}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-Input-07939", 39}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then all variables with the Input storage class decorated with Location in the Vertex Execution Model OpEntryPoint must contain a location in VkVertexInputAttributeDescription2EXT::location", 303}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-Input-08734", 39}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then the numeric type associated with all Input variables of the corresponding Location in the Vertex Execution Model OpEntryPoint must be the same as VkVertexInputAttributeDescription2EXT::format", 310}, { "chapters/drawing.html", 21} } }, @@ -4622,18 +4670,16 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndirectCount-None-04008", 38}, { {"If the nullDescriptor feature is not enabled, all vertex input bindings accessed via vertex input variables declared in the vertex shader entry point's interface must not be VK_NULL_HANDLE", 188}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-04445", 38}, { {"If the drawIndirectCount feature is not enabled this function must not be used", 78}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-04875", 38}, { {"If the bound graphics pipeline state was created with both a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage and the VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT dynamic state enabled, and the current value of primitiveTopology is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, then vkCmdSetPatchControlPointsEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 410}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-04876", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE dynamic state enabled, then vkCmdSetRasterizerDiscardEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 279}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-04877", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBiasEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 325}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-04879", 38}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 275}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-04876", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE dynamic state enabled, then vkCmdSetRasterizerDiscardEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 276}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-04877", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBiasEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 322}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-04879", 38}, { {"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 and not subsequently invalidated in the current command buffer prior to this drawing command", 272}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-04914", 38}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled then vkCmdSetVertexInputEXT must have been called and not subsequently invalidated in the current command buffer prior to this draw command", 253}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-06537", 38}, { {"Memory backing image subresources used as attachments in the current render pass must not be written in any way other than as an attachment by this command", 155}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-06539", 38}, { {"If any previously recorded command in the current subpass accessed an image subresource used as an attachment in this subpass in any way other than as an attachment, this command must not write to that image subresource as an attachment", 236}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-06666", 38}, { {"If the VK_EXT_sample_locations extension is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of sampleLocationsEnable is VK_TRUE, then vkCmdSetSampleLocationsEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 433}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-06886", 38}, { {"If the current render pass instance uses a depth/stencil attachment with a read-only layout for the depth aspect, depth writes must be disabled", 143}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-06887", 38}, { {"If the current render pass instance uses a depth/stencil attachment with a read-only layout for the stencil aspect, both front and back writeMask are not zero, and stencil test is enabled, all stencil ops must be VK_STENCIL_OP_KEEP", 231}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-07288", 38}, { {"Any shader invocation executed by this command must terminate", 61}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-07469", 38}, { {"Input attachment views accessed in a subpass must be created with the same VkFormat as the corresponding subpass definition, and be created with a VkImageView that is compatible with the attachment referenced by the subpass' pInputAttachments[InputAttachmentIndex] in the bound VkFramebuffer as specified by Fragment Input Attachment Compatibility", 347}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-07748", 38}, { {"If any shader statically accesses an input attachment, a valid descriptor must be bound to the pipeline via a descriptor set", 124}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-07831", 38}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VIEWPORT dynamic state enabled then vkCmdSetViewport must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 242}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-07832", 38}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_SCISSOR dynamic state enabled then vkCmdSetScissor must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 240}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-07834", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BIAS dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthBiasEnable is VK_TRUE, then vkCmdSetDepthBias must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 358}, { "chapters/drawing.html", 21} } }, @@ -4642,19 +4688,19 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndirectCount-None-07837", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilCompareMask must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 379}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-07838", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_WRITE_MASK dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilWriteMask must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 375}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-07839", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_REFERENCE dynamic state enabled, the current value of and rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilReference must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 374}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-07840", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_CULL_MODE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetCullModeEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 310}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-07841", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_FRONT_FACE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetFrontFaceEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 312}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-07842", 38}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopologyEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 264}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-07843", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, vkCmdSetDepthTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 320}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-07844", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthWriteEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 380}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-07845", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_COMPARE_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthCompareOpEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 372}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-07846", 38}, { {"If the depthBounds feature is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBoundsTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 374}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-07847", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetStencilTestEnableEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 329}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-07848", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilOpEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 359}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-07840", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_CULL_MODE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetCullMode must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 307}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-07841", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_FRONT_FACE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetFrontFace must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 309}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-07842", 38}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY dynamic state enabled then vkCmdSetPrimitiveTopology must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 261}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-07843", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, vkCmdSetDepthTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 317}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-07844", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthWriteEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 377}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-07845", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_COMPARE_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, and the current value of depthTestEnable is VK_TRUE, then vkCmdSetDepthCompareOp must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 369}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-07846", 38}, { {"If the depthBounds feature is enabled, a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetDepthBoundsTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 371}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-07847", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE dynamic state enabled, and the current value of rasterizerDiscardEnable is VK_FALSE, then vkCmdSetStencilTestEnable must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 326}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-07848", 38}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_STENCIL_OP dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, the current value of stencilTestEnable is VK_TRUE, then vkCmdSetStencilOp must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 356}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-07888", 38}, { {"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", 231}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-08114", 38}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid as described by descriptor validity if they are statically used by a bound shader", 176}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-08600", 38}, { {"For each set n that is statically used by a bound shader, a descriptor set must have been bound to n at the same pipeline bind point, with a VkPipelineLayout that is compatible for set n, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 299}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-08601", 38}, { {"For each push constant that is statically used by a bound shader, a push constant value must have been set for the same pipeline bind point, with a VkPipelineLayout that is compatible for push constants, with the VkPipelineLayout used to create the current VkPipeline , as described in Pipeline Layout Compatibility", 315}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-08114", 38}, { {"Descriptors in each bound descriptor set, specified via vkCmdBindDescriptorSets, must be valid if they are accessed as described by descriptor validity by a bound shader", 169}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-08600", 38}, { {"If a a bound shader statically uses a set n, 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", 286}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-08601", 38}, { {"If a a bound shader statically uses a push constant value, that 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", 248}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-08606", 38}, { {"A valid pipeline must be bound to the pipeline bind point used by this command", 78}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-08608", 38}, { {"There must not have been any calls to dynamic state setting commands for any state specified statically in the VkPipeline object bound to the pipeline bind point used by this command, since that pipeline was bound", 213}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-08609", 38}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's viewType must be VK_IMAGE_VIEW_TYPE_1D or VK_IMAGE_VIEW_TYPE_2D", 215}, { "chapters/drawing.html", 21} } }, @@ -4664,12 +4710,19 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndirectCount-None-08644", 38}, { {"If a graphics pipeline is bound, the current value of rasterizerDiscardEnable is VK_FALSE, then the current value of rasterizationSamples must be the same as the current color and/or depth/stencil attachments", 208}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-09203", 38}, { {"If the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled and VkVertexInputAttributeDescription2EXT::format has a 64-bit component, then all Input variables at the corresponding Location in the Vertex Execution Model OpEntryPoint must not use components that are not present in the format", 344}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-09600", 38}, { {"If a descriptor with type equal to any of VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT is accessed as a result of this command, all image subresources identified by that descriptor must be in the image layout identified when the descriptor was written", 313}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-09637", 38}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled, then vkCmdSetPrimitiveRestartEnableEXT must be VK_FALSE", 407}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-09637", 38}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_POINT_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, or VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled, then vkCmdSetPrimitiveRestartEnable must be VK_FALSE", 404}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-10068", 38}, { {"For each array of resources that is used by a bound shader, the indices used to access members of the array must be less than the descriptor count for the identified binding in the descriptor sets used by this command", 217}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-10795", 38}, { {"If a color attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 211}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-10796", 38}, { {"If a depth attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 211}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-None-10797", 38}, { {"If a stencil attachment is written by any prior command in this subpass or by the load, store, or resolve operations for this subpass, it must not be accessed in any way other than as an attachment by this command", 213}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-None-10909", 38}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnableEXT must be VK_FALSE", 233}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-10909", 38}, { {"If the input assembly is VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, the bound graphics pipeline state was created with the VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE dynamic state enabled then vkCmdSetPrimitiveRestartEnable must be VK_FALSE", 230}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-12338", 38}, { {"If a color attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the color attachment must not be written to by this command", 220}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-12339", 38}, { {"If a depth attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the depth attachment must not be written to by this command", 220}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-None-12340", 38}, { {"If a stencil attachment is read in this command in any way other than as an attachment, or has been read by any prior command in this subpass as a non-attachment, the stencil attachment must not be written to by this command", 224}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-OpExecutionMode-12239", 49}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the type of subdivision, they must be the same", 245}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-OpExecutionMode-12240", 49}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the orientation of triangles, they must be the same", 250}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-OpExecutionMode-12241", 49}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the segment spacing, they must be the same", 241}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-OpExecutionMode-12242", 49}, { {"If a shader is bound to both the VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT and VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT stages, and if both stages contain an OpExecutionMode instruction specifying the output patch size, they must be the same", 243}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-OpImageWrite-04469", 46}, { {"If a VkBufferView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the buffer view's format", 198}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-OpImageWrite-08795", 46}, { {"If a VkImageView is accessed using OpImageWrite as a result of this command, then the Type of the Texel operand of that instruction must have at least as many components as the image view's format", 196}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-OpTypeImage-07468", 45}, { {"If any shader executed by this pipeline accesses an OpTypeImage variable with a Dim operand of SubpassData, it must be decorated with an InputAttachmentIndex that corresponds to a valid input attachment in the current subpass", 225}, { "chapters/drawing.html", 21} } }, @@ -4680,7 +4733,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndirectCount-aspectMask-06478", 44}, { {"If a VkImageView is sampled with depth comparison, the image view must have been created with an aspectMask that contains VK_IMAGE_ASPECT_DEPTH_BIT", 147}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-blendEnable-04727", 45}, { {"If a graphics pipeline is bound which was created with VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT dynamic state enabled, the current value of rasterizerDiscardEnable is VK_FALSE, then for each color attachment, if the corresponding image view's format features do not contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT, then the corresponding current value of blendEnable must be VK_FALSE", 387}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-buffer-02708", 40}, { {"If buffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 107}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-buffer-02709", 40}, { {"buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set", 82}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-buffer-02709", 40}, { {"buffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT usage flag set", 89}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-buffer-parameter", 44}, { {"buffer must be a valid VkBuffer handle", 38}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-commandBuffer-02707", 47}, { {"If commandBuffer is an unprotected command buffer and protectedNoFault is not supported, any resource accessed by bound shaders must not be a protected resource", 160}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-commandBuffer-02711", 47}, { {"commandBuffer must not be a protected command buffer", 52}, { "chapters/drawing.html", 21} } }, @@ -4689,7 +4742,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndirectCount-commandBuffer-recording", 51}, { {"commandBuffer must be in the recording state", 44}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-commonparent", 40}, { {"Each of buffer, commandBuffer, and countBuffer must have been created, allocated, or retrieved from the same VkDevice", 117}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-countBuffer-02714", 45}, { {"If countBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 112}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-countBuffer-02715", 45}, { {"countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT bit set", 87}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-countBuffer-02715", 45}, { {"countBuffer must have been created with the VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT usage flag set", 94}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-countBuffer-02717", 45}, { {"The count stored in countBuffer must be less than or equal to VkPhysicalDeviceLimits::maxDrawIndirectCount", 106}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-countBuffer-parameter", 49}, { {"countBuffer must be a valid VkBuffer handle", 43}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-countBufferOffset-02716", 51}, { {"countBufferOffset must be a multiple of 4", 41}, { "chapters/drawing.html", 21} } }, @@ -4712,15 +4765,15 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndirectCount-mipmapMode-04770", 44}, { {"If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR, reductionMode equal to VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, and compareEnable equal to VK_FALSE is used to sample a VkImageView as a result of this command, then the image view's format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT", 343}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-mipmapMode-09599", 44}, { {"If a VkSampler created with mipmapMode equal to VK_SAMPLER_MIPMAP_MODE_LINEAR and reductionMode equal to either VK_SAMPLER_REDUCTION_MODE_MIN or VK_SAMPLER_REDUCTION_MODE_MAX is used to sample a VkImageView as a result of this command, then the image view's format features must contain VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT", 336}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-offset-02710", 40}, { {"offset must be a multiple of 4", 30}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-pStrides-04913", 42}, { {"If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE dynamic state enabled, but without the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2EXT must have been called and not subsequently invalidated in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2EXT must not be NULL", 411}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-primitiveFragmentShadingRateWithMultipleViewports-04552", 83}, { {"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 vkCmdSetViewportWithCountEXT must have been called in the current command buffer prior to this drawing command, and the viewportCount parameter of vkCmdSetViewportWithCountEXT must be 1", 487}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-pStrides-04913", 42}, { {"If the bound graphics pipeline was created with the VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE dynamic state enabled, but without the VK_DYNAMIC_STATE_VERTEX_INPUT_EXT dynamic state enabled, then vkCmdBindVertexBuffers2 must have been called and not subsequently invalidated in the current command buffer prior to this draw command, and the pStrides parameter of vkCmdBindVertexBuffers2 must not be NULL", 405}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-primitiveFragmentShadingRateWithMultipleViewports-04552", 83}, { {"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 vkCmdSetViewportWithCountEXT must be 1", 484}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-primitiveTopology-10286", 51}, { {"If a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage is bound, then the current value of primitiveTopology must be VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command", 176}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-primitiveTopology-10747", 51}, { {"If vkCmdSetPrimitiveTopologyEXT set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command, then a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage must be bound", 188}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-primitiveTopology-10748", 51}, { {"If vkCmdSetPrimitiveTopologyEXT set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_POINT_LIST prior to this drawing command, both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT and VK_SHADER_STAGE_GEOMETRY_BIT stage are not bound, then the Vertex Execution Model must have a PointSize decorated variable that is statically written to", 328}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-primitiveTopology-10747", 51}, { {"If vkCmdSetPrimitiveTopology set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_PATCH_LIST prior to this drawing command, then a VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT stage must be bound", 185}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-primitiveTopology-10748", 51}, { {"If vkCmdSetPrimitiveTopology set primitiveTopology to VK_PRIMITIVE_TOPOLOGY_POINT_LIST prior to this drawing command, both a VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT and VK_SHADER_STAGE_GEOMETRY_BIT stage are not bound, then the Vertex Execution Model must have a PointSize decorated variable that is statically written to", 325}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-renderPass-02684", 44}, { {"The current render pass must be compatible with the renderPass member of the VkGraphicsPipelineCreateInfo structure specified when creating the VkPipeline bound to VK_PIPELINE_BIND_POINT_GRAPHICS", 195}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-renderpass", 38}, { {"This command must only be called inside of a render pass instance", 65}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-sampleLocationsEnable-02689", 55}, { {"If the bound graphics pipeline was created with VkPipelineSampleLocationsStateCreateInfoEXT::sampleLocationsEnable set to VK_TRUE, then the active depth attachment must have been created with the VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT bit set", 261}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-scissorCount-03418", 46}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT dynamic state enabled, then vkCmdSetScissorWithCountEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing", 257}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-scissorCount-03418", 46}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT dynamic state enabled, then vkCmdSetScissorWithCount must have been called and not subsequently invalidated in the current command buffer prior to this drawing", 254}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-sparseImageInt64Atomics-04474", 57}, { {"If the sparseImageInt64Atomics feature is not enabled, VkImage objects created with the VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", 250}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-sparseImageInt64Atomics-04475", 57}, { {"If the sparseImageInt64Atomics feature is not enabled, VkBuffer objects created with the VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT flag must not be accessed by atomic instructions through an OpTypeImage with a SampledType with a Width of 64 by this command", 252}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-storageBuffers-06936", 48}, { {"If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a storage buffer, 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", 311}, { "chapters/drawing.html", 21} } }, @@ -4729,7 +4782,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdDrawIndirectCount-uniformBuffers-06935", 48}, { {"If any stage of the VkPipeline object bound to the pipeline bind point used by this command accesses a uniform buffer, 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", 311}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-unnormalizedCoordinates-09635", 57}, { {"If a VkSampler created with unnormalizedCoordinates equal to VK_TRUE is used to sample a VkImageView as a result of this command, then the image view's levelCount and layerCount must be 1", 187}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-viewType-07752", 42}, { {"If a VkImageView is accessed as a result of this command, then the image view's viewType must match the Dim operand of the OpTypeImage as described in Compatibility Between SPIR-V Image Dimensions and Vulkan ImageView Types", 223}, { "chapters/drawing.html", 21} } }, - { {"VUID-vkCmdDrawIndirectCount-viewportCount-03417", 47}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, then vkCmdSetViewportWithCountEXT must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 267}, { "chapters/drawing.html", 21} } }, + { {"VUID-vkCmdDrawIndirectCount-viewportCount-03417", 47}, { {"If a graphics pipeline is bound which was created with the VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic state enabled, then vkCmdSetViewportWithCount must have been called and not subsequently invalidated in the current command buffer prior to this drawing command", 264}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdDrawIndirectCount-viewportCount-03419", 47}, { {"If a graphics pipeline is bound which was created with both the VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT and VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT dynamic states enabled, then the viewportCount parameter of vkCmdSetViewportWithCountEXT must match the scissorCount parameter of vkCmdSetScissorWithCountEXT", 298}, { "chapters/drawing.html", 21} } }, { {"VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01912", 51}, { {"There must be an outstanding vkCmdBeginDebugUtilsLabelEXT command prior to the vkCmdEndDebugUtilsLabelEXT on the queue that commandBuffer is submitted to", 153}, { "chapters/debugging.html", 23} } }, { {"VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01913", 51}, { {"If commandBuffer is a secondary command buffer, there must be an outstanding vkCmdBeginDebugUtilsLabelEXT command recorded to commandBuffer that has not previously been ended by a call to vkCmdEndDebugUtilsLabelEXT", 214}, { "chapters/debugging.html", 23} } }, @@ -4802,7 +4855,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdFillBuffer-commandBuffer-parameter", 44}, { {"commandBuffer must be a valid VkCommandBuffer handle", 52}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdFillBuffer-commandBuffer-recording", 44}, { {"commandBuffer must be in the recording state", 44}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdFillBuffer-commonparent", 33}, { {"Both of commandBuffer, and dstBuffer must have been created, allocated, or retrieved from the same VkDevice", 107}, { "chapters/clears.html", 20} } }, - { {"VUID-vkCmdFillBuffer-dstBuffer-00029", 36}, { {"dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag", 81}, { "chapters/clears.html", 20} } }, + { {"VUID-vkCmdFillBuffer-dstBuffer-00029", 36}, { {"dstBuffer must have been created with the VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag set", 89}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdFillBuffer-dstBuffer-00031", 36}, { {"If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 110}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdFillBuffer-dstBuffer-parameter", 40}, { {"dstBuffer must be a valid VkBuffer handle", 41}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdFillBuffer-dstOffset-00024", 36}, { {"dstOffset must be less than the size of dstBuffer", 49}, { "chapters/clears.html", 20} } }, @@ -4851,11 +4904,11 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdPipelineBarrier-image-04073", 37}, { {"If vkCmdPipelineBarrier is called within a render pass instance using a VkRenderPass object, the image member of any image memory barrier included in this command must be an attachment used in the current subpass both as an input attachment, and as either a color, or depth/stencil attachment", 292}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdPipelineBarrier-oldLayout-01181", 41}, { {"If vkCmdPipelineBarrier is called within a render pass instance, the oldLayout and newLayout members of any image memory barrier included in this command must be equal", 167}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdPipelineBarrier-oldLayout-10758", 41}, { {"If called within a render pass instance using a VkRenderPass object, the oldLayout member of any image memory barrier included in this command must be equal to the layout that the corresponding attachment uses during the subpass", 228}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-02817", 53}, { {"For any element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types", 434}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-02818", 53}, { {"For any element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types", 434}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-02817", 53}, { {"For each element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types", 435}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-02818", 53}, { {"For each element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types", 435}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-parameter", 57}, { {"If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures", 162}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-02819", 52}, { {"For any element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types", 433}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-02820", 52}, { {"For any element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types", 433}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-02819", 52}, { {"For each element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types", 434}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-02820", 52}, { {"For each element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types", 434}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdPipelineBarrier-pImageMemoryBarriers-parameter", 56}, { {"If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures", 158}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdPipelineBarrier-pMemoryBarriers-parameter", 51}, { {"If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures", 138}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdPipelineBarrier-srcAccessMask-02815", 45}, { {"The srcAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types", 216}, { "chapters/synchronization.html", 29} } }, @@ -4866,8 +4919,8 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdPipelineBarrier-srcStageMask-04091", 44}, { {"If the tessellationShader feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT", 185}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdPipelineBarrier-srcStageMask-06461", 44}, { {"Any pipeline stage included in srcStageMask must be supported by the capabilities of the queue family specified by the queueFamilyIndex member of the VkCommandPoolCreateInfo structure that was used to create the VkCommandPool that commandBuffer was allocated from, as specified in the table of supported pipeline stages", 319}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdPipelineBarrier-srcStageMask-07319", 44}, { {"If the attachmentFragmentShadingRate feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR", 149}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdPipelineBarrier-srcStageMask-09633", 44}, { {"If either srcStageMask or dstStageMask includes VK_PIPELINE_STAGE_HOST_BIT, for any element of pImageMemoryBarriers, srcQueueFamilyIndex and dstQueueFamilyIndex must be equal", 174}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdPipelineBarrier-srcStageMask-09634", 44}, { {"If either srcStageMask or dstStageMask includes VK_PIPELINE_STAGE_HOST_BIT, for any element of pBufferMemoryBarriers, srcQueueFamilyIndex and dstQueueFamilyIndex must be equal", 175}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdPipelineBarrier-srcStageMask-09633", 44}, { {"If either srcStageMask or dstStageMask includes VK_PIPELINE_STAGE_HOST_BIT, for each element of pImageMemoryBarriers, srcQueueFamilyIndex and dstQueueFamilyIndex must be equal", 175}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdPipelineBarrier-srcStageMask-09634", 44}, { {"If either srcStageMask or dstStageMask includes VK_PIPELINE_STAGE_HOST_BIT, for each element of pBufferMemoryBarriers, srcQueueFamilyIndex and dstQueueFamilyIndex must be equal", 176}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdPipelineBarrier-srcStageMask-parameter", 48}, { {"srcStageMask must be a valid combination of VkPipelineStageFlagBits values", 74}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdPipelineBarrier2-None-07889", 37}, { {"If vkCmdPipelineBarrier2KHR is called within a render pass instance using a VkRenderPass object, the render pass must have been created with at least one subpass dependency that expresses a dependency from the current subpass to itself, does not include VK_DEPENDENCY_BY_REGION_BIT if this command does not, does not include VK_DEPENDENCY_VIEW_LOCAL_BIT if this command does not, and has synchronization scopes and access scopes that are all supersets of the scopes defined in this command", 489}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdPipelineBarrier2-None-07890", 37}, { {"If vkCmdPipelineBarrier2KHR is called within a render pass instance, and the source stage masks of any memory barriers include framebuffer-space stages, destination stage masks of all memory barriers must only include framebuffer-space stages", 242}, { "chapters/synchronization.html", 29} } }, @@ -4915,7 +4968,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdResetEvent-commandBuffer-recording", 44}, { {"commandBuffer must be in the recording state", 44}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdResetEvent-commonparent", 33}, { {"Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice", 103}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdResetEvent-event-03834", 32}, { {"There must be an execution dependency between vkCmdResetEvent and the execution of any vkCmdWaitEvents that includes event in its pEvents parameter", 147}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdResetEvent-event-03835", 32}, { {"There must be an execution dependency between vkCmdResetEvent and the execution of any vkCmdWaitEvents2KHR that includes event in its pEvents parameter", 151}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdResetEvent-event-03835", 32}, { {"There must be an execution dependency between vkCmdResetEvent and the execution of any vkCmdWaitEvents2 that includes event in its pEvents parameter", 148}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdResetEvent-event-parameter", 36}, { {"event must be a valid VkEvent handle", 36}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdResetEvent-renderpass", 31}, { {"This command must only be called outside of a render pass instance", 66}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdResetEvent-stageMask-01153", 36}, { {"stageMask must not include VK_PIPELINE_STAGE_HOST_BIT", 53}, { "chapters/synchronization.html", 29} } }, @@ -4931,7 +4984,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdResetEvent2-commandBuffer-recording", 45}, { {"commandBuffer must be in the recording state", 44}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdResetEvent2-commonparent", 34}, { {"Both of commandBuffer, and event must have been created, allocated, or retrieved from the same VkDevice", 103}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdResetEvent2-event-03831", 33}, { {"There must be an execution dependency between vkCmdResetEvent2KHR and the execution of any vkCmdWaitEvents that includes event in its pEvents parameter", 151}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdResetEvent2-event-03832", 33}, { {"There must be an execution dependency between vkCmdResetEvent2KHR and the execution of any vkCmdWaitEvents2KHR that includes event in its pEvents parameter", 155}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdResetEvent2-event-03832", 33}, { {"There must be an execution dependency between vkCmdResetEvent2KHR and the execution of any vkCmdWaitEvents2 that includes event in its pEvents parameter", 152}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdResetEvent2-event-parameter", 37}, { {"event must be a valid VkEvent handle", 36}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdResetEvent2-renderpass", 32}, { {"This command must only be called outside of a render pass instance", 66}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdResetEvent2-stageMask-03830", 37}, { {"stageMask must not include VK_PIPELINE_STAGE_2_HOST_BIT", 55}, { "chapters/synchronization.html", 29} } }, @@ -4962,7 +5015,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdResolveImage-dstImage-00276", 37}, { {"If dstImage is of type VK_IMAGE_TYPE_1D, then for each element of pRegions, dstOffset.y must be 0 and extent.height must be 1", 125}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdResolveImage-dstImage-00278", 37}, { {"If dstImage is of type VK_IMAGE_TYPE_1D or VK_IMAGE_TYPE_2D, then for each element of pRegions, dstOffset.z must be 0 and extent.depth must be 1", 144}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdResolveImage-dstImage-02003", 37}, { {"The format features of dstImage must contain VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT", 83}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdResolveImage-dstImage-06764", 37}, { {"dstImage must have been created with VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag", 79}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdResolveImage-dstImage-06764", 37}, { {"dstImage must have been created with the VK_IMAGE_USAGE_TRANSFER_DST_BIT usage flag set", 87}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdResolveImage-dstImage-06765", 37}, { {"The format features of dstImage must contain VK_FORMAT_FEATURE_TRANSFER_DST_BIT", 79}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdResolveImage-dstImage-parameter", 41}, { {"dstImage must be a valid VkImage handle", 39}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdResolveImage-dstImageLayout-00262", 43}, { {"dstImageLayout must specify the layout of the image subresources of dstImage specified in pRegions at the time this command is executed on a VkDevice", 149}, { "chapters/copies.html", 20} } }, @@ -4985,7 +5038,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdResolveImage-srcImage-01386", 37}, { {"srcImage and dstImage must have been created with the same image format", 71}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdResolveImage-srcImage-04446", 37}, { {"If dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, srcSubresource.layerCount must be 1", 111}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdResolveImage-srcImage-04447", 37}, { {"If dstImage is of type VK_IMAGE_TYPE_3D, then for each element of pRegions, dstSubresource.baseArrayLayer must be 0 and dstSubresource.layerCount must be 1", 155}, { "chapters/copies.html", 20} } }, - { {"VUID-vkCmdResolveImage-srcImage-06762", 37}, { {"srcImage must have been created with VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag", 79}, { "chapters/copies.html", 20} } }, + { {"VUID-vkCmdResolveImage-srcImage-06762", 37}, { {"srcImage must have been created with the VK_IMAGE_USAGE_TRANSFER_SRC_BIT usage flag set", 87}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdResolveImage-srcImage-06763", 37}, { {"The format features of srcImage must contain VK_FORMAT_FEATURE_TRANSFER_SRC_BIT", 79}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdResolveImage-srcImage-parameter", 41}, { {"srcImage must be a valid VkImage handle", 39}, { "chapters/copies.html", 20} } }, { {"VUID-vkCmdResolveImage-srcImageLayout-00260", 43}, { {"srcImageLayout must specify the layout of the image subresources of srcImage specified in pRegions at the time this command is executed on a VkDevice", 149}, { "chapters/copies.html", 20} } }, @@ -5252,7 +5305,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdUpdateBuffer-dataSize-00037", 37}, { {"dataSize must be less than or equal to 65536", 44}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdUpdateBuffer-dataSize-00038", 37}, { {"dataSize must be a multiple of 4", 32}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdUpdateBuffer-dataSize-arraylength", 43}, { {"dataSize must be greater than 0", 31}, { "chapters/clears.html", 20} } }, - { {"VUID-vkCmdUpdateBuffer-dstBuffer-00034", 38}, { {"dstBuffer must have been created with VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag", 81}, { "chapters/clears.html", 20} } }, + { {"VUID-vkCmdUpdateBuffer-dstBuffer-00034", 38}, { {"dstBuffer must have been created with the VK_BUFFER_USAGE_TRANSFER_DST_BIT usage flag set", 89}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdUpdateBuffer-dstBuffer-00035", 38}, { {"If dstBuffer is non-sparse then it must be bound completely and contiguously to a single VkDeviceMemory object", 110}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdUpdateBuffer-dstBuffer-parameter", 42}, { {"dstBuffer must be a valid VkBuffer handle", 41}, { "chapters/clears.html", 20} } }, { {"VUID-vkCmdUpdateBuffer-dstOffset-00032", 38}, { {"dstOffset must be less than the size of dstBuffer", 49}, { "chapters/clears.html", 20} } }, @@ -5272,16 +5325,18 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdWaitEvents-dstStageMask-07319", 39}, { {"If the attachmentFragmentShadingRate feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR", 149}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents-dstStageMask-parameter", 43}, { {"dstStageMask must be a valid combination of VkPipelineStageFlagBits values", 74}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents-eventCount-arraylength", 43}, { {"eventCount must be greater than 0", 33}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdWaitEvents-pBufferMemoryBarriers-02817", 48}, { {"For any element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types", 434}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdWaitEvents-pBufferMemoryBarriers-02818", 48}, { {"For any element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types", 434}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdWaitEvents-oldLayout-01181", 36}, { {"If vkCmdWaitEvents is called within a render pass instance, the oldLayout and newLayout members of any image memory barrier included in this command must be equal", 162}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdWaitEvents-pBufferMemoryBarriers-02817", 48}, { {"For each element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types", 435}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdWaitEvents-pBufferMemoryBarriers-02818", 48}, { {"For each element of pBufferMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types", 435}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents-pBufferMemoryBarriers-parameter", 52}, { {"If bufferMemoryBarrierCount is not 0, pBufferMemoryBarriers must be a valid pointer to an array of bufferMemoryBarrierCount valid VkBufferMemoryBarrier structures", 162}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdWaitEvents-pEvents-03847", 34}, { {"Elements of pEvents must not have been signaled by vkCmdSetEvent2KHR", 68}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdWaitEvents-pEvents-03847", 34}, { {"Elements of pEvents must not have been signaled by vkCmdSetEvent2", 65}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents-pEvents-parameter", 38}, { {"pEvents must be a valid pointer to an array of eventCount valid VkEvent handles", 79}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdWaitEvents-pImageMemoryBarriers-02819", 47}, { {"For any element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types", 433}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdWaitEvents-pImageMemoryBarriers-02820", 47}, { {"For any element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types", 433}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdWaitEvents-pImageMemoryBarriers-02819", 47}, { {"For each element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its srcQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its srcAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types", 434}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdWaitEvents-pImageMemoryBarriers-02820", 47}, { {"For each element of pImageMemoryBarriers, if its srcQueueFamilyIndex and dstQueueFamilyIndex members are equal, or if its dstQueueFamilyIndex is the queue family index that was used to create the command pool that commandBuffer was allocated from, then its dstAccessMask member must only contain access flags that are supported by one or more of the pipeline stages in dstStageMask, as specified in the table of supported access types", 434}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents-pImageMemoryBarriers-parameter", 51}, { {"If imageMemoryBarrierCount is not 0, pImageMemoryBarriers must be a valid pointer to an array of imageMemoryBarrierCount valid VkImageMemoryBarrier structures", 158}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents-pMemoryBarriers-parameter", 46}, { {"If memoryBarrierCount is not 0, pMemoryBarriers must be a valid pointer to an array of memoryBarrierCount valid VkMemoryBarrier structures", 138}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents-srcAccessMask-02815", 40}, { {"The srcAccessMask member of each element of pMemoryBarriers must only include access flags that are supported by one or more of the pipeline stages in srcStageMask, as specified in the table of supported access types", 216}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdWaitEvents-srcQueueFamilyIndex-01182", 46}, { {"If vkCmdWaitEvents is called within a render pass instance, the srcQueueFamilyIndex and dstQueueFamilyIndex members of any memory barrier included in this command must be equal", 176}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents-srcQueueFamilyIndex-02803", 46}, { {"The srcQueueFamilyIndex and dstQueueFamilyIndex members of any element of pBufferMemoryBarriers or pImageMemoryBarriers must be equal", 133}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents-srcStageMask-01158", 39}, { {"srcStageMask must be the bitwise OR of the stageMask parameter used in previous calls to vkCmdSetEvent with any of the elements of pEvents and VK_PIPELINE_STAGE_HOST_BIT if any of the elements of pEvents was set using vkSetEvent", 228}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents-srcStageMask-03937", 39}, { {"If the synchronization2 feature is not enabled, srcStageMask must not be 0", 74}, { "chapters/synchronization.html", 29} } }, @@ -5300,13 +5355,15 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCmdWaitEvents2-dependencyFlags-10394", 43}, { {"The dependencyFlags member of any element of pDependencyInfo must not include any of the following bits: VK_DEPENDENCY_BY_REGION_BIT VK_DEPENDENCY_DEVICE_GROUP_BIT VK_DEPENDENCY_VIEW_LOCAL_BIT", 192}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents2-dstStageMask-03843", 40}, { {"The dstStageMask member of any element of the pMemoryBarriers, pBufferMemoryBarriers, or pImageMemoryBarriers members of pDependencyInfos must only include pipeline stages valid for the queue family that was used to create the command pool that commandBuffer was allocated from", 277}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents2-eventCount-arraylength", 44}, { {"eventCount must be greater than 0", 33}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdWaitEvents2-oldLayout-01181", 37}, { {"If vkCmdWaitEvents2KHR is called within a render pass instance, the oldLayout and newLayout members of any image memory barrier included in this command must be equal", 166}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents2-pDependencyInfos-parameter", 48}, { {"pDependencyInfos must be a valid pointer to an array of eventCount valid VkDependencyInfo structures", 100}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents2-pEvents-03837", 35}, { {"Members of pEvents must not have been signaled by vkCmdSetEvent", 63}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdWaitEvents2-pEvents-03839", 35}, { {"For any element i of pEvents, if that event is signaled by vkSetEvent, barriers in the ith element of pDependencyInfos must include only host operations in their first synchronization scope", 189}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdWaitEvents2-pEvents-03840", 35}, { {"For any element i of pEvents, if barriers in the ith element of pDependencyInfos include only host operations, the ith element of pEvents must be signaled before vkCmdWaitEvents2KHR is executed", 193}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdWaitEvents2-pEvents-03841", 35}, { {"For any element i of pEvents, if barriers in the ith element of pDependencyInfos do not include host operations, the ith element of pEvents must be signaled by a corresponding vkCmdSetEvent2KHR that occurred earlier in submission order", 235}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkCmdWaitEvents2-pEvents-10788", 35}, { {"For any element i of pEvents, if that event is signaled by vkCmdSetEvent2KHR, that command's dependencyInfo parameter must be exactly equal to the ith element of pDependencyInfos", 178}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdWaitEvents2-pEvents-03839", 35}, { {"For each element i of pEvents, if that event is signaled by vkSetEvent, barriers in the ith element of pDependencyInfos must include only host operations in their first synchronization scope", 190}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdWaitEvents2-pEvents-03840", 35}, { {"For each element i of pEvents, if barriers in the ith element of pDependencyInfos include only host operations, the ith element of pEvents must be signaled before vkCmdWaitEvents2 is executed", 191}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdWaitEvents2-pEvents-03841", 35}, { {"For each element i of pEvents, if barriers in the ith element of pDependencyInfos do not include host operations, the ith element of pEvents must be signaled by a corresponding vkCmdSetEvent2 that occurred earlier in submission order", 233}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdWaitEvents2-pEvents-10788", 35}, { {"For each element i of pEvents, if that event is signaled by vkCmdSetEvent2, that command's dependencyInfo parameter must be exactly equal to the ith element of pDependencyInfos", 176}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents2-pEvents-parameter", 39}, { {"pEvents must be a valid pointer to an array of eventCount valid VkEvent handles", 79}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkCmdWaitEvents2-srcQueueFamilyIndex-01182", 47}, { {"If vkCmdWaitEvents2KHR is called within a render pass instance, the srcQueueFamilyIndex and dstQueueFamilyIndex members of any memory barrier included in this command must be equal", 180}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents2-srcStageMask-03842", 40}, { {"The srcStageMask member of any element of the pMemoryBarriers, pBufferMemoryBarriers, or pImageMemoryBarriers members of pDependencyInfos must only include pipeline stages valid for the queue family that was used to create the command pool that commandBuffer was allocated from", 277}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWaitEvents2-synchronization2-03836", 44}, { {"The synchronization2 feature must be enabled", 44}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkCmdWriteTimestamp-None-00830", 35}, { {"All queries used by the command must be unavailable", 51}, { "chapters/queries.html", 21} } }, @@ -5395,7 +5452,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkCreateDevice-pCreateInfo-parameter", 41}, { {"pCreateInfo must be a valid pointer to a valid VkDeviceCreateInfo structure", 75}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-vkCreateDevice-pDevice-parameter", 37}, { {"pDevice must be a valid pointer to a VkDevice handle", 52}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-vkCreateDevice-physicalDevice-parameter", 44}, { {"physicalDevice must be a valid VkPhysicalDevice handle", 54}, { "chapters/devsandqueues.html", 27} } }, - { {"VUID-vkCreateDevice-ppEnabledExtensionNames-01387", 49}, { {"All required device extensions for each extension in the VkDeviceCreateInfo::ppEnabledExtensionNames list must also be present in that list.", 140}, { "chapters/devsandqueues.html", 27} } }, + { {"VUID-vkCreateDevice-ppEnabledExtensionNames-01387", 49}, { {"All required device extensions for each extension in the VkDeviceCreateInfo::ppEnabledExtensionNames list must also be present in that list", 139}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-vkCreateDevice-samplerRequestCount-05096", 45}, { {"The sum of samplerRequestCount over all VkDeviceObjectReservationCreateInfo structures included in the VkDeviceCreateInfo::pNext chain must be less than or equal to VkPhysicalDeviceLimits::maxSamplerAllocationCount", 214}, { "chapters/devsandqueues.html", 27} } }, { {"VUID-vkCreateDisplayModeKHR-display-parameter", 45}, { {"display must be a valid VkDisplayKHR handle", 43}, { "chapters/VK_KHR_surface/wsi.html", 32} } }, { {"VUID-vkCreateDisplayModeKHR-display-parent", 42}, { {"display must have been created, allocated, or retrieved from physicalDevice", 75}, { "chapters/VK_KHR_surface/wsi.html", 32} } }, @@ -5596,7 +5653,6 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkDestroyPipelineCache-pipelineCache-parent", 48}, { {"If pipelineCache is a valid handle, it must have been created, allocated, or retrieved from device", 98}, { "chapters/pipelines.html", 23} } }, { {"VUID-vkDestroyPipelineLayout-device-parameter", 45}, { {"device must be a valid VkDevice handle", 38}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-vkDestroyPipelineLayout-pAllocator-null", 44}, { {"pAllocator must be NULL", 23}, { "chapters/descriptorsets.html", 28} } }, - { {"VUID-vkDestroyPipelineLayout-pipelineLayout-02004", 49}, { {"pipelineLayout must not have been passed to any vkCmd* command for any command buffers that are still in the recording state when vkDestroyPipelineLayout is called", 163}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-vkDestroyPipelineLayout-pipelineLayout-parameter", 53}, { {"If pipelineLayout is not VK_NULL_HANDLE, pipelineLayout must be a valid VkPipelineLayout handle", 95}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-vkDestroyPipelineLayout-pipelineLayout-parent", 50}, { {"If pipelineLayout is a valid handle, it must have been created, allocated, or retrieved from device", 99}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-vkDestroyRenderPass-device-parameter", 41}, { {"device must be a valid VkDevice handle", 38}, { "chapters/renderpass.html", 24} } }, @@ -5867,9 +5923,11 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkGetPhysicalDeviceFeatures-physicalDevice-parameter", 57}, { {"physicalDevice must be a valid VkPhysicalDevice handle", 54}, { "chapters/features.html", 22} } }, { {"VUID-vkGetPhysicalDeviceFeatures2-pFeatures-parameter", 53}, { {"pFeatures must be a valid pointer to a VkPhysicalDeviceFeatures2 structure", 74}, { "chapters/features.html", 22} } }, { {"VUID-vkGetPhysicalDeviceFeatures2-physicalDevice-parameter", 58}, { {"physicalDevice must be a valid VkPhysicalDevice handle", 54}, { "chapters/features.html", 22} } }, + { {"VUID-vkGetPhysicalDeviceFormatProperties-None-12272", 51}, { {"If the ycbcr2plane444Formats feature is not supported, format must not be VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, or VK_FORMAT_G16_B16R16_2PLANE_444_UNORM", 256}, { "chapters/formats.html", 21} } }, { {"VUID-vkGetPhysicalDeviceFormatProperties-format-parameter", 57}, { {"format must be a valid VkFormat value", 37}, { "chapters/formats.html", 21} } }, { {"VUID-vkGetPhysicalDeviceFormatProperties-pFormatProperties-parameter", 68}, { {"pFormatProperties must be a valid pointer to a VkFormatProperties structure", 75}, { "chapters/formats.html", 21} } }, { {"VUID-vkGetPhysicalDeviceFormatProperties-physicalDevice-parameter", 65}, { {"physicalDevice must be a valid VkPhysicalDevice handle", 54}, { "chapters/formats.html", 21} } }, + { {"VUID-vkGetPhysicalDeviceFormatProperties2-None-12273", 52}, { {"If the ycbcr2plane444Formats feature is not supported, format must not be VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, or VK_FORMAT_G16_B16R16_2PLANE_444_UNORM", 256}, { "chapters/formats.html", 21} } }, { {"VUID-vkGetPhysicalDeviceFormatProperties2-format-parameter", 58}, { {"format must be a valid VkFormat value", 37}, { "chapters/formats.html", 21} } }, { {"VUID-vkGetPhysicalDeviceFormatProperties2-pFormatProperties-parameter", 69}, { {"pFormatProperties must be a valid pointer to a VkFormatProperties2 structure", 76}, { "chapters/formats.html", 21} } }, { {"VUID-vkGetPhysicalDeviceFormatProperties2-physicalDevice-parameter", 66}, { {"physicalDevice must be a valid VkPhysicalDevice handle", 54}, { "chapters/formats.html", 21} } }, @@ -5970,19 +6028,22 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkGetQueryPoolResults-device-parameter", 43}, { {"device must be a valid VkDevice handle", 38}, { "chapters/queries.html", 21} } }, { {"VUID-vkGetQueryPoolResults-firstQuery-09436", 43}, { {"firstQuery must be less than the number of queries in queryPool", 63}, { "chapters/queries.html", 21} } }, { {"VUID-vkGetQueryPoolResults-firstQuery-09437", 43}, { {"The sum of firstQuery and queryCount must be less than or equal to the number of queries in queryPool", 101}, { "chapters/queries.html", 21} } }, - { {"VUID-vkGetQueryPoolResults-flags-00815", 38}, { {"If VK_QUERY_RESULT_64_BIT is set in flags then pData and stride must be multiples of 8", 86}, { "chapters/queries.html", 21} } }, - { {"VUID-vkGetQueryPoolResults-flags-02828", 38}, { {"If VK_QUERY_RESULT_64_BIT is not set in flags and the queryType used to create queryPool was not VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then pData and stride must be multiples of 4", 178}, { "chapters/queries.html", 21} } }, + { {"VUID-vkGetQueryPoolResults-flags-00815", 38}, { {"If VK_QUERY_RESULT_64_BIT is set in flags then pData must be aligned to a multiple of 8", 87}, { "chapters/queries.html", 21} } }, + { {"VUID-vkGetQueryPoolResults-flags-02828", 38}, { {"If VK_QUERY_RESULT_64_BIT is not set in flags and the queryType used to create queryPool was not VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then pData must be aligned to a multiple of 4", 179}, { "chapters/queries.html", 21} } }, { {"VUID-vkGetQueryPoolResults-flags-parameter", 42}, { {"flags must be a valid combination of VkQueryResultFlagBits values", 65}, { "chapters/queries.html", 21} } }, { {"VUID-vkGetQueryPoolResults-pData-parameter", 42}, { {"pData must be a valid pointer to an array of dataSize bytes", 59}, { "chapters/queries.html", 21} } }, { {"VUID-vkGetQueryPoolResults-queryCount-09438", 43}, { {"If queryCount is greater than 1, stride must not be zero", 56}, { "chapters/queries.html", 21} } }, + { {"VUID-vkGetQueryPoolResults-queryCount-12251", 43}, { {"If queryCount is greater than 1, VK_QUERY_RESULT_64_BIT is not set in flags and the queryType used to create queryPool was not VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then stride must be a multiple of 4", 199}, { "chapters/queries.html", 21} } }, + { {"VUID-vkGetQueryPoolResults-queryCount-12252", 43}, { {"If queryCount is greater than 1 and VK_QUERY_RESULT_64_BIT is set in flags, then stride must be a multiple of 8", 111}, { "chapters/queries.html", 21} } }, + { {"VUID-vkGetQueryPoolResults-queryCount-12253", 43}, { {"If queryCount is greater than 1 and the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then stride must be a multiple of the size of VkPerformanceCounterResultKHR", 191}, { "chapters/queries.html", 21} } }, { {"VUID-vkGetQueryPoolResults-queryPool-parameter", 46}, { {"queryPool must be a valid VkQueryPool handle", 44}, { "chapters/queries.html", 21} } }, { {"VUID-vkGetQueryPoolResults-queryPool-parent", 43}, { {"queryPool must have been created, allocated, or retrieved from device", 69}, { "chapters/queries.html", 21} } }, - { {"VUID-vkGetQueryPoolResults-queryType-03229", 42}, { {"If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then pData and stride must be multiples of the size of VkPerformanceCounterResultKHR", 167}, { "chapters/queries.html", 21} } }, - { {"VUID-vkGetQueryPoolResults-queryType-04519", 42}, { {"If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then stride must be large enough to contain the VkQueryPoolPerformanceCreateInfoKHR::counterIndexCount used to create queryPool times the size of VkPerformanceCounterResultKHR", 258}, { "chapters/queries.html", 21} } }, + { {"VUID-vkGetQueryPoolResults-queryType-03229", 42}, { {"If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then pData must be aligned to a multiple of the size of VkPerformanceCounterResultKHR", 168}, { "chapters/queries.html", 21} } }, + { {"VUID-vkGetQueryPoolResults-queryType-04519", 42}, { {"If queryCount is greater than 1 and the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, then stride must be large enough to contain the VkQueryPoolPerformanceCreateInfoKHR::counterIndexCount used to create queryPool times the size of VkPerformanceCounterResultKHR", 291}, { "chapters/queries.html", 21} } }, { {"VUID-vkGetQueryPoolResults-queryType-09439", 42}, { {"If the queryType used to create queryPool was VK_QUERY_TYPE_TIMESTAMP, flags must not contain VK_QUERY_RESULT_PARTIAL_BIT", 121}, { "chapters/queries.html", 21} } }, { {"VUID-vkGetQueryPoolResults-queryType-09440", 42}, { {"If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, flags must not contain VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, VK_QUERY_RESULT_PARTIAL_BIT, or VK_QUERY_RESULT_64_BIT", 199}, { "chapters/queries.html", 21} } }, { {"VUID-vkGetQueryPoolResults-queryType-09441", 42}, { {"If the queryType used to create queryPool was VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR, the queryPool must have been recorded once for each pass as retrieved via a call to vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", 222}, { "chapters/queries.html", 21} } }, - { {"VUID-vkGetQueryPoolResults-stride-08993", 39}, { {"If VK_QUERY_RESULT_WITH_AVAILABILITY_BIT is set, stride must be large enough to contain the unsigned integer representing availability in addition to the query result", 166}, { "chapters/queries.html", 21} } }, + { {"VUID-vkGetQueryPoolResults-stride-08993", 39}, { {"If queryCount is greater than 1 and VK_QUERY_RESULT_WITH_AVAILABILITY_BIT is set, stride must be large enough to contain the unsigned integer representing availability in addition to the query result", 199}, { "chapters/queries.html", 21} } }, { {"VUID-vkGetRenderAreaGranularity-device-parameter", 48}, { {"device must be a valid VkDevice handle", 38}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkGetRenderAreaGranularity-pGranularity-parameter", 54}, { {"pGranularity must be a valid pointer to a VkExtent2D structure", 62}, { "chapters/renderpass.html", 24} } }, { {"VUID-vkGetRenderAreaGranularity-renderPass-parameter", 52}, { {"renderPass must be a valid VkRenderPass handle", 46}, { "chapters/renderpass.html", 24} } }, @@ -6141,7 +6202,7 @@ const vvl::unordered_map &GetVuidMap() { { {"VUID-vkResetDescriptorPool-flags-zerobitmask", 44}, { {"flags must be 0", 15}, { "chapters/descriptorsets.html", 28} } }, { {"VUID-vkResetEvent-device-parameter", 34}, { {"device must be a valid VkDevice handle", 38}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkResetEvent-event-03821", 29}, { {"There must be an execution dependency between vkResetEvent and the execution of any vkCmdWaitEvents that includes event in its pEvents parameter", 144}, { "chapters/synchronization.html", 29} } }, - { {"VUID-vkResetEvent-event-03822", 29}, { {"There must be an execution dependency between vkResetEvent and the execution of any vkCmdWaitEvents2KHR that includes event in its pEvents parameter", 148}, { "chapters/synchronization.html", 29} } }, + { {"VUID-vkResetEvent-event-03822", 29}, { {"There must be an execution dependency between vkResetEvent and the execution of any vkCmdWaitEvents2 that includes event in its pEvents parameter", 145}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkResetEvent-event-03823", 29}, { {"event must not have been created with VK_EVENT_CREATE_DEVICE_ONLY_BIT", 69}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkResetEvent-event-parameter", 33}, { {"event must be a valid VkEvent handle", 36}, { "chapters/synchronization.html", 29} } }, { {"VUID-vkResetEvent-event-parent", 30}, { {"event must have been created, allocated, or retrieved from device", 65}, { "chapters/synchronization.html", 29} } }, diff --git a/scripts/known_good.json b/scripts/known_good.json index a3158cf23..36e3c9758 100644 --- a/scripts/known_good.json +++ b/scripts/known_good.json @@ -19,7 +19,7 @@ "cmake_options": [ "-DGEN_VULKANSC_COMBINED=ON" ], - "commit": "ba3b55609702243722fea9db42941a4ebc9a50c0" + "commit": "vksc1.0.21" }, { "name": "Vulkan-Utility-Libraries", @@ -43,7 +43,7 @@ "sub_dir": "Vulkan-Utility-Libraries", "build_dir": "Vulkan-Utility-Libraries/build", "install_dir": "Vulkan-Utility-Libraries/build/install", - "commit": "50a3c053901e12559b5c1942da8d6c5f3c34eb98", + "commit": "vksc1.0.21", "deps": [ { "var_name": "VULKAN_HEADERS_INSTALL_DIR", @@ -140,7 +140,7 @@ "sub_dir": "Vulkan-Loader", "build_dir": "Vulkan-Loader/build", "install_dir": "Vulkan-Loader/build/install", - "commit": "vksc1.0.20", + "commit": "vksc1.0.21", "build_step": "skip", "optional": [ "tests" @@ -166,7 +166,7 @@ "sub_dir": "Vulkan-Tools", "build_dir": "Vulkan-Tools/build", "install_dir": "Vulkan-Tools/build/install", - "commit": "9859d70e5c031271ee9a959883337cf10bfc5b93", + "commit": "vksc1.0.21", "build_step": "skip", "optional": [ "tests" diff --git a/tests/icd/VVL_Test_ICD_vksc.json.in b/tests/icd/VVL_Test_ICD_vksc.json.in index d0adc69e6..0758cbeca 100644 --- a/tests/icd/VVL_Test_ICD_vksc.json.in +++ b/tests/icd/VVL_Test_ICD_vksc.json.in @@ -2,6 +2,6 @@ "file_format_version": "1.0.1", "ICD": { "library_path": "@JSON_LIBRARY_PATH@", - "api_version": "1.0.20" + "api_version": "1.0.21" } } \ No newline at end of file diff --git a/tests/vulkansc/device_profiles/max_core.json b/tests/vulkansc/device_profiles/max_core.json index c87a0c20b..d83eee28e 100644 --- a/tests/vulkansc/device_profiles/max_core.json +++ b/tests/vulkansc/device_profiles/max_core.json @@ -3,7 +3,7 @@ "profiles": { "MAX_CORE": { "version": 1, - "api-version": "1.0.20", + "api-version": "1.0.21", "label": "Max Vulkan SC Core", "description": "Max Vulkan SC Core profile", "contributors": {}, diff --git a/tests/vulkansc/device_profiles/max_profile.json b/tests/vulkansc/device_profiles/max_profile.json index 6ed285b0b..34ed6aaa2 100644 --- a/tests/vulkansc/device_profiles/max_profile.json +++ b/tests/vulkansc/device_profiles/max_profile.json @@ -3,7 +3,7 @@ "profiles": { "MAX_PROFILE": { "version": 1, - "api-version": "1.0.20", + "api-version": "1.0.21", "label": "Max Vulkan SC Profile", "description": "Profile that supports everything possible", "contributors": {}, diff --git a/tests/vulkansc/device_profiles/min_core.json b/tests/vulkansc/device_profiles/min_core.json index b19dcbe93..66f374f33 100644 --- a/tests/vulkansc/device_profiles/min_core.json +++ b/tests/vulkansc/device_profiles/min_core.json @@ -3,7 +3,7 @@ "profiles": { "MIN_CORE": { "version": 1, - "api-version": "1.0.20", + "api-version": "1.0.21", "label": "Min Vulkan SC Core", "description": "Min Vulkan SC Core profile", "contributors": {},